saeeol 1.0.8 → 1.1.0

package/src/cli/cmd/tui/context/theme/synthwave84.json

@@ -1,226 +0,0 @@
-{
-  "$schema": "https://saeeol.ai/theme.json",
-  "defs": {
-    "background": "#262335",
-    "backgroundAlt": "#1e1a29",
-    "backgroundPanel": "#2a2139",
-    "foreground": "#ffffff",
-    "foregroundMuted": "#848bbd",
-    "pink": "#ff7edb",
-    "pinkBright": "#ff92df",
-    "cyan": "#36f9f6",
-    "cyanBright": "#72f1f8",
-    "yellow": "#fede5d",
-    "yellowBright": "#fff95d",
-    "orange": "#ff8b39",
-    "orangeBright": "#ff9f43",
-    "purple": "#b084eb",
-    "purpleBright": "#c792ea",
-    "red": "#fe4450",
-    "redBright": "#ff5e5b",
-    "green": "#72f1b8",
-    "greenBright": "#97f1d8"
-  },
-  "theme": {
-    "primary": {
-      "dark": "cyan",
-      "light": "#00bcd4"
-    },
-    "secondary": {
-      "dark": "pink",
-      "light": "#e91e63"
-    },
-    "accent": {
-      "dark": "purple",
-      "light": "#9c27b0"
-    },
-    "error": {
-      "dark": "red",
-      "light": "#f44336"
-    },
-    "warning": {
-      "dark": "yellow",
-      "light": "#ff9800"
-    },
-    "success": {
-      "dark": "green",
-      "light": "#4caf50"
-    },
-    "info": {
-      "dark": "orange",
-      "light": "#ff5722"
-    },
-    "text": {
-      "dark": "foreground",
-      "light": "#262335"
-    },
-    "textMuted": {
-      "dark": "foregroundMuted",
-      "light": "#5c5c8a"
-    },
-    "background": {
-      "dark": "#262335",
-      "light": "#fafafa"
-    },
-    "backgroundPanel": {
-      "dark": "#1e1a29",
-      "light": "#f5f5f5"
-    },
-    "backgroundElement": {
-      "dark": "#2a2139",
-      "light": "#eeeeee"
-    },
-    "border": {
-      "dark": "#495495",
-      "light": "#e0e0e0"
-    },
-    "borderActive": {
-      "dark": "cyan",
-      "light": "#00bcd4"
-    },
-    "borderSubtle": {
-      "dark": "#241b2f",
-      "light": "#f0f0f0"
-    },
-    "diffAdded": {
-      "dark": "green",
-      "light": "#4caf50"
-    },
-    "diffRemoved": {
-      "dark": "red",
-      "light": "#f44336"
-    },
-    "diffContext": {
-      "dark": "foregroundMuted",
-      "light": "#5c5c8a"
-    },
-    "diffHunkHeader": {
-      "dark": "purple",
-      "light": "#9c27b0"
-    },
-    "diffHighlightAdded": {
-      "dark": "greenBright",
-      "light": "#4caf50"
-    },
-    "diffHighlightRemoved": {
-      "dark": "redBright",
-      "light": "#f44336"
-    },
-    "diffAddedBg": {
-      "dark": "#1a3a2a",
-      "light": "#e8f5e9"
-    },
-    "diffRemovedBg": {
-      "dark": "#3a1a2a",
-      "light": "#ffebee"
-    },
-    "diffContextBg": {
-      "dark": "#1e1a29",
-      "light": "#f5f5f5"
-    },
-    "diffLineNumber": {
-      "dark": "#959bc1",
-      "light": "textMuted"
-    },
-    "diffAddedLineNumberBg": {
-      "dark": "#1a3a2a",
-      "light": "#e8f5e9"
-    },
-    "diffRemovedLineNumberBg": {
-      "dark": "#3a1a2a",
-      "light": "#ffebee"
-    },
-    "markdownText": {
-      "dark": "foreground",
-      "light": "#262335"
-    },
-    "markdownHeading": {
-      "dark": "pink",
-      "light": "#e91e63"
-    },
-    "markdownLink": {
-      "dark": "cyan",
-      "light": "#00bcd4"
-    },
-    "markdownLinkText": {
-      "dark": "purple",
-      "light": "#9c27b0"
-    },
-    "markdownCode": {
-      "dark": "green",
-      "light": "#4caf50"
-    },
-    "markdownBlockQuote": {
-      "dark": "foregroundMuted",
-      "light": "#5c5c8a"
-    },
-    "markdownEmph": {
-      "dark": "yellow",
-      "light": "#ff9800"
-    },
-    "markdownStrong": {
-      "dark": "orange",
-      "light": "#ff5722"
-    },
-    "markdownHorizontalRule": {
-      "dark": "#495495",
-      "light": "#e0e0e0"
-    },
-    "markdownListItem": {
-      "dark": "cyan",
-      "light": "#00bcd4"
-    },
-    "markdownListEnumeration": {
-      "dark": "purple",
-      "light": "#9c27b0"
-    },
-    "markdownImage": {
-      "dark": "cyan",
-      "light": "#00bcd4"
-    },
-    "markdownImageText": {
-      "dark": "purple",
-      "light": "#9c27b0"
-    },
-    "markdownCodeBlock": {
-      "dark": "foreground",
-      "light": "#262335"
-    },
-    "syntaxComment": {
-      "dark": "foregroundMuted",
-      "light": "#5c5c8a"
-    },
-    "syntaxKeyword": {
-      "dark": "pink",
-      "light": "#e91e63"
-    },
-    "syntaxFunction": {
-      "dark": "orange",
-      "light": "#ff5722"
-    },
-    "syntaxVariable": {
-      "dark": "foreground",
-      "light": "#262335"
-    },
-    "syntaxString": {
-      "dark": "yellow",
-      "light": "#ff9800"
-    },
-    "syntaxNumber": {
-      "dark": "purple",
-      "light": "#9c27b0"
-    },
-    "syntaxType": {
-      "dark": "cyan",
-      "light": "#00bcd4"
-    },
-    "syntaxOperator": {
-      "dark": "pink",
-      "light": "#e91e63"
-    },
-    "syntaxPunctuation": {
-      "dark": "foreground",
-      "light": "#262335"
-    }
-  }
-}

package/src/cli/cmd/tui/context/theme/theme-resolve.ts

@@ -1,86 +0,0 @@
-import { RGBA } from "@opentui/core"
-import type { Theme, ThemeColor, ColorValue, ThemeJson } from "./theme-types"
-
-export function resolveTheme(theme: ThemeJson, mode: "dark" | "light") {
-  const defs = theme.defs ?? {}
-  function resolveColor(c: ColorValue, chain: string[] = []): RGBA {
-    if (c instanceof RGBA) return c
-    if (typeof c === "string") {
-      if (c === "transparent" || c === "none") return RGBA.fromInts(0, 0, 0, 0)
-
-      if (c.startsWith("#")) return RGBA.fromHex(c)
-
-      if (chain.includes(c)) {
-        throw new Error(`Circular color reference: ${[...chain, c].join(" -> ")}`)
-      }
-
-      const next = defs[c] ?? theme.theme[c as ThemeColor]
-      if (next === undefined) {
-        throw new Error(`Color reference "${c}" not found in defs or theme`)
-      }
-      return resolveColor(next, [...chain, c])
-    }
-    if (typeof c === "number") {
-      return ansiToRgba(c)
-    }
-    return resolveColor(c[mode], chain)
-  }
-
-  const resolved = Object.fromEntries(
-    Object.entries(theme.theme)
-      .filter(([key]) => key !== "selectedListItemText" && key !== "backgroundMenu" && key !== "thinkingOpacity")
-      .map(([key, value]) => {
-        return [key, resolveColor(value as ColorValue)]
-      }),
-  ) as Partial<Record<ThemeColor, RGBA>>
-
-  const hasSelectedListItemText = theme.theme.selectedListItemText !== undefined
-  if (hasSelectedListItemText) {
-    resolved.selectedListItemText = resolveColor(theme.theme.selectedListItemText!)
-  } else {
-    resolved.selectedListItemText = resolved.background
-  }
-
-  if (theme.theme.backgroundMenu !== undefined) {
-    resolved.backgroundMenu = resolveColor(theme.theme.backgroundMenu)
-  } else {
-    resolved.backgroundMenu = resolved.backgroundElement
-  }
-
-  const thinkingOpacity = theme.theme.thinkingOpacity ?? 0.6
-
-  return {
-    ...resolved,
-    _hasSelectedListItemText: hasSelectedListItemText,
-    thinkingOpacity,
-  } as Theme
-}
-
-export function ansiToRgba(code: number): RGBA {
-  if (code < 16) {
-    const ansiColors = [
-      "#000000", "#800000", "#008000", "#808000",
-      "#000080", "#800080", "#008080", "#c0c0c0",
-      "#808080", "#ff0000", "#00ff00", "#ffff00",
-      "#0000ff", "#ff00ff", "#00ffff", "#ffffff",
-    ]
-    return RGBA.fromHex(ansiColors[code] ?? "#000000")
-  }
-
-  if (code < 232) {
-    const index = code - 16
-    const b = index % 6
-    const g = Math.floor(index / 6) % 6
-    const r = Math.floor(index / 36)
-
-    const val = (x: number) => (x === 0 ? 0 : x * 40 + 55)
-    return RGBA.fromInts(val(r), val(g), val(b))
-  }
-
-  if (code < 256) {
-    const gray = (code - 232) * 10 + 8
-    return RGBA.fromInts(gray, gray, gray)
-  }
-
-  return RGBA.fromInts(0, 0, 0)
-}

package/src/cli/cmd/tui/context/theme/theme-syntax-code.ts

@@ -1,47 +0,0 @@
-import type { Theme } from "./theme-types"
-
-export function getCodeSyntaxRules(theme: Theme) {
-  return [
-    { scope: ["default"], style: { foreground: theme.text } },
-    { scope: ["prompt"], style: { foreground: theme.accent } },
-    { scope: ["extmark.file"], style: { foreground: theme.warning, bold: true } },
-    { scope: ["extmark.agent"], style: { foreground: theme.secondary, bold: true } },
-    { scope: ["extmark.paste"], style: { foreground: theme.background, background: theme.warning, bold: true } },
-    { scope: ["comment"], style: { foreground: theme.syntaxComment, italic: true } },
-    { scope: ["comment.documentation"], style: { foreground: theme.syntaxComment, italic: true } },
-    { scope: ["string", "symbol"], style: { foreground: theme.syntaxString } },
-    { scope: ["number", "boolean"], style: { foreground: theme.syntaxNumber } },
-    { scope: ["character.special"], style: { foreground: theme.syntaxString } },
-    {
-      scope: ["keyword.return", "keyword.conditional", "keyword.repeat", "keyword.coroutine"],
-      style: { foreground: theme.syntaxKeyword, italic: true },
-    },
-    { scope: ["keyword.type"], style: { foreground: theme.syntaxType, bold: true, italic: true } },
-    { scope: ["keyword.function", "function.method"], style: { foreground: theme.syntaxFunction } },
-    { scope: ["keyword"], style: { foreground: theme.syntaxKeyword, italic: true } },
-    { scope: ["keyword.import"], style: { foreground: theme.syntaxKeyword } },
-    { scope: ["operator", "keyword.operator", "punctuation.delimiter"], style: { foreground: theme.syntaxOperator } },
-    { scope: ["keyword.conditional.ternary"], style: { foreground: theme.syntaxOperator } },
-    {
-      scope: ["variable", "variable.parameter", "function.method.call", "function.call"],
-      style: { foreground: theme.syntaxVariable },
-    },
-    { scope: ["variable.member", "function", "constructor"], style: { foreground: theme.syntaxFunction } },
-    { scope: ["type", "module"], style: { foreground: theme.syntaxType } },
-    { scope: ["constant"], style: { foreground: theme.syntaxNumber } },
-    { scope: ["property"], style: { foreground: theme.syntaxVariable } },
-    { scope: ["class"], style: { foreground: theme.syntaxType } },
-    { scope: ["parameter"], style: { foreground: theme.syntaxVariable } },
-    { scope: ["punctuation", "punctuation.bracket"], style: { foreground: theme.syntaxPunctuation } },
-    {
-      scope: ["variable.builtin", "type.builtin", "function.builtin", "module.builtin", "constant.builtin"],
-      style: { foreground: theme.error },
-    },
-    { scope: ["variable.super"], style: { foreground: theme.error } },
-    { scope: ["string.escape", "string.regexp"], style: { foreground: theme.syntaxKeyword } },
-    { scope: ["keyword.directive"], style: { foreground: theme.syntaxKeyword, italic: true } },
-    { scope: ["punctuation.special"], style: { foreground: theme.syntaxOperator } },
-    { scope: ["keyword.modifier"], style: { foreground: theme.syntaxKeyword, italic: true } },
-    { scope: ["keyword.exception"], style: { foreground: theme.syntaxKeyword, italic: true } },
-  ]
-}

package/src/cli/cmd/tui/context/theme/theme-syntax-markup.ts

@@ -1,50 +0,0 @@
-import type { Theme } from "./theme-types"
-
-export function getMarkupSyntaxRules(theme: Theme) {
-  return [
-    { scope: ["markup.heading"], style: { foreground: theme.markdownHeading, bold: true } },
-    { scope: ["markup.heading.1"], style: { foreground: theme.markdownHeading, bold: true } },
-    { scope: ["markup.heading.2"], style: { foreground: theme.markdownHeading, bold: true } },
-    { scope: ["markup.heading.3"], style: { foreground: theme.markdownHeading, bold: true } },
-    { scope: ["markup.heading.4"], style: { foreground: theme.markdownHeading, bold: true } },
-    { scope: ["markup.heading.5"], style: { foreground: theme.markdownHeading, bold: true } },
-    { scope: ["markup.heading.6"], style: { foreground: theme.markdownHeading, bold: true } },
-    { scope: ["markup.bold", "markup.strong"], style: { foreground: theme.markdownStrong, bold: true } },
-    { scope: ["markup.italic"], style: { foreground: theme.markdownEmph, italic: true } },
-    { scope: ["markup.list"], style: { foreground: theme.markdownListItem } },
-    { scope: ["markup.quote"], style: { foreground: theme.markdownBlockQuote, italic: true } },
-    { scope: ["markup.raw", "markup.raw.block"], style: { foreground: theme.markdownCode } },
-    { scope: ["markup.raw.inline"], style: { foreground: theme.markdownCode, background: theme.background } },
-    { scope: ["markup.link"], style: { foreground: theme.markdownLink, underline: true } },
-    { scope: ["markup.link.label"], style: { foreground: theme.markdownLinkText, underline: true } },
-    { scope: ["markup.link.url"], style: { foreground: theme.markdownLink, underline: true } },
-    { scope: ["label"], style: { foreground: theme.markdownLinkText } },
-    { scope: ["spell", "nospell"], style: { foreground: theme.text } },
-    { scope: ["conceal"], style: { foreground: theme.textMuted } },
-    { scope: ["string.special", "string.special.url"], style: { foreground: theme.markdownLink, underline: true } },
-    { scope: ["character"], style: { foreground: theme.syntaxString } },
-    { scope: ["float"], style: { foreground: theme.syntaxNumber } },
-    { scope: ["comment.error"], style: { foreground: theme.error, italic: true, bold: true } },
-    { scope: ["comment.warning"], style: { foreground: theme.warning, italic: true, bold: true } },
-    { scope: ["comment.todo", "comment.note"], style: { foreground: theme.info, italic: true, bold: true } },
-    { scope: ["namespace"], style: { foreground: theme.syntaxType } },
-    { scope: ["field"], style: { foreground: theme.syntaxVariable } },
-    { scope: ["type.definition"], style: { foreground: theme.syntaxType, bold: true } },
-    { scope: ["keyword.export"], style: { foreground: theme.syntaxKeyword } },
-    { scope: ["attribute", "annotation"], style: { foreground: theme.warning } },
-    { scope: ["tag"], style: { foreground: theme.error } },
-    { scope: ["tag.attribute"], style: { foreground: theme.syntaxKeyword } },
-    { scope: ["tag.delimiter"], style: { foreground: theme.syntaxOperator } },
-    { scope: ["markup.strikethrough"], style: { foreground: theme.textMuted } },
-    { scope: ["markup.underline"], style: { foreground: theme.text, underline: true } },
-    { scope: ["markup.list.checked"], style: { foreground: theme.success } },
-    { scope: ["markup.list.unchecked"], style: { foreground: theme.textMuted } },
-    { scope: ["diff.plus"], style: { foreground: theme.diffAdded, background: theme.diffAddedBg } },
-    { scope: ["diff.minus"], style: { foreground: theme.diffRemoved, background: theme.diffRemovedBg } },
-    { scope: ["diff.delta"], style: { foreground: theme.diffContext, background: theme.diffContextBg } },
-    { scope: ["error"], style: { foreground: theme.error, bold: true } },
-    { scope: ["warning"], style: { foreground: theme.warning, bold: true } },
-    { scope: ["info"], style: { foreground: theme.info } },
-    { scope: ["debug"], style: { foreground: theme.textMuted } },
-  ]
-}

package/src/cli/cmd/tui/context/theme/theme-syntax.ts

@@ -1,36 +0,0 @@
-import { SyntaxStyle, RGBA } from "@opentui/core"
-import type { Theme } from "./theme-types"
-import { getCodeSyntaxRules } from "./theme-syntax-code"
-import { getMarkupSyntaxRules } from "./theme-syntax-markup"
-
-export function getSyntaxRules(theme: Theme) {
-  return [...getCodeSyntaxRules(theme), ...getMarkupSyntaxRules(theme)]
-}
-
-export function generateSyntax(theme: Theme) {
-  return SyntaxStyle.fromTheme(getSyntaxRules(theme))
-}
-
-export function generateSubtleSyntax(theme: Theme) {
-  const rules = getSyntaxRules(theme)
-  return SyntaxStyle.fromTheme(
-    rules.map((rule) => {
-      if (rule.style.foreground) {
-        const fg = rule.style.foreground
-        return {
-          ...rule,
-          style: {
-            ...rule.style,
-            foreground: RGBA.fromInts(
-              Math.round(fg.r * 255),
-              Math.round(fg.g * 255),
-              Math.round(fg.b * 255),
-              Math.round(theme.thinkingOpacity * 255),
-            ),
-          },
-        }
-      }
-      return rule
-    }),
-  )
-}

package/src/cli/cmd/tui/context/theme/theme-system.ts

@@ -1,158 +0,0 @@
-import { RGBA, type TerminalColors } from "@opentui/core"
-import { tint } from "./theme-types"
-import { ansiToRgba } from "./theme-resolve"
-import type { ThemeJson } from "./theme-types"
-
-export function generateSystem(colors: TerminalColors, mode: "dark" | "light"): ThemeJson {
-  const bg = RGBA.fromHex(colors.defaultBackground ?? colors.palette[0]!)
-  const fg = RGBA.fromHex(colors.defaultForeground ?? colors.palette[7]!)
-  const transparent = RGBA.fromValues(bg.r, bg.g, bg.b, 0)
-  const isDark = mode == "dark"
-
-  const col = (i: number) => {
-    const value = colors.palette[i]
-    if (value) return RGBA.fromHex(value)
-    return ansiToRgba(i)
-  }
-
-  const grays = generateGrayScale(bg, isDark)
-  const textMuted = generateMutedTextColor(bg, isDark)
-
-  const ansiColors = {
-    black: col(0),
-    red: col(1),
-    green: col(2),
-    yellow: col(3),
-    blue: col(4),
-    magenta: col(5),
-    cyan: col(6),
-    white: col(7),
-    redBright: col(9),
-    greenBright: col(10),
-  }
-
-  const diffAlpha = isDark ? 0.22 : 0.14
-  const diffAddedBg = tint(bg, ansiColors.green, diffAlpha)
-  const diffRemovedBg = tint(bg, ansiColors.red, diffAlpha)
-  const diffContextBg = grays[2]
-  const diffAddedLineNumberBg = tint(diffContextBg, ansiColors.green, diffAlpha)
-  const diffRemovedLineNumberBg = tint(diffContextBg, ansiColors.red, diffAlpha)
-  const diffLineNumber = textMuted
-
-  return {
-    theme: {
-      primary: ansiColors.cyan,
-      secondary: ansiColors.magenta,
-      accent: ansiColors.cyan,
-      error: ansiColors.red,
-      warning: ansiColors.yellow,
-      success: ansiColors.green,
-      info: ansiColors.cyan,
-      text: fg,
-      textMuted,
-      selectedListItemText: bg,
-      background: transparent,
-      backgroundPanel: grays[2],
-      backgroundElement: grays[3],
-      backgroundMenu: grays[3],
-      borderSubtle: grays[6],
-      border: grays[7],
-      borderActive: grays[8],
-      diffAdded: ansiColors.green,
-      diffRemoved: ansiColors.red,
-      diffContext: grays[7],
-      diffHunkHeader: grays[7],
-      diffHighlightAdded: ansiColors.greenBright,
-      diffHighlightRemoved: ansiColors.redBright,
-      diffAddedBg,
-      diffRemovedBg,
-      diffContextBg,
-      diffLineNumber,
-      diffAddedLineNumberBg,
-      diffRemovedLineNumberBg,
-      markdownText: fg,
-      markdownHeading: fg,
-      markdownLink: ansiColors.blue,
-      markdownLinkText: ansiColors.cyan,
-      markdownCode: ansiColors.green,
-      markdownBlockQuote: ansiColors.yellow,
-      markdownEmph: ansiColors.yellow,
-      markdownStrong: fg,
-      markdownHorizontalRule: grays[7],
-      markdownListItem: ansiColors.blue,
-      markdownListEnumeration: ansiColors.cyan,
-      markdownImage: ansiColors.blue,
-      markdownImageText: ansiColors.cyan,
-      markdownCodeBlock: fg,
-      syntaxComment: textMuted,
-      syntaxKeyword: ansiColors.magenta,
-      syntaxFunction: ansiColors.blue,
-      syntaxVariable: fg,
-      syntaxString: ansiColors.green,
-      syntaxNumber: ansiColors.yellow,
-      syntaxType: ansiColors.cyan,
-      syntaxOperator: ansiColors.cyan,
-      syntaxPunctuation: fg,
-    },
-  }
-}
-
-function generateGrayScale(bg: RGBA, isDark: boolean): Record<number, RGBA> {
-  const grays: Record<number, RGBA> = {}
-  const bgR = bg.r * 255
-  const bgG = bg.g * 255
-  const bgB = bg.b * 255
-  const luminance = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB
-
-  for (let i = 1; i <= 12; i++) {
-    const factor = i / 12.0
-    let newR: number
-    let newG: number
-    let newB: number
-
-    if (isDark) {
-      if (luminance < 10) {
-        const grayValue = Math.floor(factor * 0.4 * 255)
-        newR = grayValue
-        newG = grayValue
-        newB = grayValue
-      } else {
-        const newLum = luminance + (255 - luminance) * factor * 0.4
-        const ratio = newLum / luminance
-        newR = Math.min(bgR * ratio, 255)
-        newG = Math.min(bgG * ratio, 255)
-        newB = Math.min(bgB * ratio, 255)
-      }
-    } else {
-      if (luminance > 245) {
-        const grayValue = Math.floor(255 - factor * 0.4 * 255)
-        newR = grayValue
-        newG = grayValue
-        newB = grayValue
-      } else {
-        const newLum = luminance * (1 - factor * 0.4)
-        const ratio = newLum / luminance
-        newR = Math.max(bgR * ratio, 0)
-        newG = Math.max(bgG * ratio, 0)
-        newB = Math.max(bgB * ratio, 0)
-      }
-    }
-
-    grays[i] = RGBA.fromInts(Math.floor(newR), Math.floor(newG), Math.floor(newB))
-  }
-
-  return grays
-}
-
-function generateMutedTextColor(bg: RGBA, isDark: boolean): RGBA {
-  const bgR = bg.r * 255
-  const bgG = bg.g * 255
-  const bgB = bg.b * 255
-  const bgLum = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB
-
-  const grayValue = isDark
-    ? bgLum < 10 ? 180 : Math.min(Math.floor(160 + bgLum * 0.3), 200)
-    : bgLum > 245 ? 75 : Math.max(Math.floor(100 - (255 - bgLum) * 0.2), 60)
-
-  return RGBA.fromInts(grayValue, grayValue, grayValue)
-}

package/src/cli/cmd/tui/context/theme/theme-themes.ts

@@ -1,79 +0,0 @@
-import aura from "./aura.json" with { type: "json" }
-import ayu from "./ayu.json" with { type: "json" }
-import catppuccin from "./catppuccin.json" with { type: "json" }
-import catppuccinFrappe from "./catppuccin-frappe.json" with { type: "json" }
-import catppuccinMacchiato from "./catppuccin-macchiato.json" with { type: "json" }
-import cobalt2 from "./cobalt2.json" with { type: "json" }
-import cursor from "./cursor.json" with { type: "json" }
-import dracula from "./dracula.json" with { type: "json" }
-import everforest from "./everforest.json" with { type: "json" }
-import flexoki from "./flexoki.json" with { type: "json" }
-import github from "./github.json" with { type: "json" }
-import gruvbox from "./gruvbox.json" with { type: "json" }
-import kanagawa from "./kanagawa.json" with { type: "json" }
-import saeeol from "./saeeol.json" with { type: "json" }
-import material from "./material.json" with { type: "json" }
-import matrix from "./matrix.json" with { type: "json" }
-import mercury from "./mercury.json" with { type: "json" }
-import monokai from "./monokai.json" with { type: "json" }
-import nightowl from "./nightowl.json" with { type: "json" }
-import nord from "./nord.json" with { type: "json" }
-import osakaJade from "./osaka-jade.json" with { type: "json" }
-import onedark from "./one-dark.json" with { type: "json" }
-import orng from "./orng.json" with { type: "json" }
-import lucentOrng from "./lucent-orng.json" with { type: "json" }
-import palenight from "./palenight.json" with { type: "json" }
-import rosepine from "./rosepine.json" with { type: "json" }
-import solarized from "./solarized.json" with { type: "json" }
-import synthwave84 from "./synthwave84.json" with { type: "json" }
-import tokyonight from "./tokyonight.json" with { type: "json" }
-import vercel from "./vercel.json" with { type: "json" }
-import vesper from "./vesper.json" with { type: "json" }
-import zenburn from "./zenburn.json" with { type: "json" }
-import carbonfox from "./carbonfox.json" with { type: "json" }
-import colorblind from "./colorblind.json" with { type: "json" }
-import type { ThemeJson } from "./theme-types"
-
-export const DEFAULT_THEMES: Record<string, ThemeJson> = {
-  aura,
-  ayu,
-  catppuccin,
-  ["catppuccin-frappe"]: catppuccinFrappe,
-  ["catppuccin-macchiato"]: catppuccinMacchiato,
-  cobalt2,
-  cursor,
-  dracula,
-  everforest,
-  flexoki,
-  github,
-  gruvbox,
-  kanagawa,
-  saeeol,
-  material,
-  matrix,
-  mercury,
-  monokai,
-  nightowl,
-  nord,
-  ["one-dark"]: onedark,
-  ["osaka-jade"]: osakaJade,
-  orng,
-  ["lucent-orng"]: lucentOrng,
-  palenight,
-  rosepine,
-  solarized,
-  synthwave84,
-  tokyonight,
-  vesper,
-  vercel,
-  zenburn,
-  carbonfox,
-  colorblind,
-}
-
-export function isValidTheme(t: unknown): t is ThemeJson {
-  if (t == null || typeof t !== "object" || !("theme" in t)) return false
-  const theme = (t as Record<string, unknown>).theme
-  if (theme == null || typeof theme !== "object") return false
-  return "background" in theme && "text" in theme && "primary" in theme
-}