refactor: consolidate resolvers into domain-focused modules

Split resolvers.ts into theme.ts and language.ts for better organization:
- theme.ts: resolveTheme, toShikiOptions, getMultiThemeOptions, DEFAULT_THEMES
- language.ts: resolveLanguage, isPlaintext helper
- options.ts: simplified to import from theme.ts

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: AVGVSTVS96

package/src/lib/component.tsx

@@ -1,6 +1,6 @@
 import './styles.css';
 import { clsx } from 'clsx';
-import { resolveLanguage } from './resolvers';
+import { resolveLanguage } from './language';
 
 import type {
   HighlighterOptions,

package/src/lib/hook.ts

@@ -20,7 +20,8 @@ import type {
 } from './types';
 
 import { throttleHighlighting, useStableOptions } from './utils';
-import { resolveLanguage, resolveTheme } from './resolvers';
+import { resolveLanguage } from './language';
+import { resolveTheme } from './theme';
 import { buildShikiOptions } from './options';
 import { transformOutput } from './output';
 

package/src/lib/language.ts

@@ -0,0 +1,77 @@
+import type { Language } from './types';
+import type { LanguageRegistration } from './extended-types';
+
+export type LanguageResolution = {
+  languageId: string;
+  displayLanguageId: string | null;
+  langsToLoad: Language;
+};
+
+export const resolveLanguage = (
+  lang: Language,
+  customLanguages?: LanguageRegistration | LanguageRegistration[],
+  langAliases?: Record<string, string>
+): LanguageResolution => {
+  const normalizedCustomLangs = customLanguages
+    ? Array.isArray(customLanguages)
+      ? customLanguages
+      : [customLanguages]
+    : [];
+
+  if (lang == null || (typeof lang === 'string' && !lang.trim())) {
+    return {
+      languageId: 'plaintext',
+      displayLanguageId: 'plaintext',
+      langsToLoad: undefined,
+    };
+  }
+
+  if (typeof lang === 'object') {
+    return {
+      languageId: lang.name,
+      displayLanguageId: lang.name || null,
+      langsToLoad: lang,
+    };
+  }
+
+  const lowerLang = lang.toLowerCase();
+  const matches = (str: string | undefined): boolean =>
+    str?.toLowerCase() === lowerLang;
+
+  const customMatch = normalizedCustomLangs.find(
+    (cl) =>
+      matches(cl.name) ||
+      matches(cl.scopeName) ||
+      matches(cl.scopeName?.split('.').pop()) ||
+      cl.aliases?.some(matches) ||
+      cl.fileTypes?.some(matches)
+  );
+
+  if (customMatch) {
+    return {
+      languageId: customMatch.name || lang,
+      displayLanguageId: lang,
+      langsToLoad: customMatch,
+    };
+  }
+
+  if (langAliases?.[lang]) {
+    return {
+      languageId: langAliases[lang],
+      displayLanguageId: lang,
+      langsToLoad: langAliases[lang],
+    };
+  }
+
+  // Fallback handled in highlighter factories
+  return {
+    languageId: lang,
+    displayLanguageId: lang,
+    langsToLoad: lang,
+  };
+};
+
+const PLAINTEXT_LANGS = new Set(['text', 'plaintext', 'txt', 'plain']);
+
+export const isPlaintext = (resolution: LanguageResolution): boolean =>
+  PLAINTEXT_LANGS.has(resolution.languageId);

package/src/lib/options.ts

@@ -1,40 +1,13 @@
-import type {
-  CodeToHastOptions,
-  CodeOptionsSingleTheme,
-  CodeOptionsMultipleThemes,
-  BundledTheme,
-} from 'shiki';
+import type { CodeToHastOptions } from 'shiki';
 
-import type { HighlighterOptions, OutputFormat, Themes } from './types';
-import type { ThemeResult } from './resolvers';
+import type { HighlighterOptions, OutputFormat } from './types';
+import type { ThemeResolution } from './theme';
+import { toShikiOptions, getMultiThemeOptions } from './theme';
 import { lineNumbersTransformer } from './transformers';
 
-const DEFAULT_THEMES: Themes = {
-  light: 'github-light',
-  dark: 'github-dark',
-};
-
-const buildThemeOptions = (
-  themeResult: ThemeResult
-):
-  | CodeOptionsSingleTheme<BundledTheme>
-  | CodeOptionsMultipleThemes<BundledTheme> => {
-  const { isMultiTheme, multiTheme, singleTheme } = themeResult;
-
-  if (isMultiTheme) {
-    return {
-      themes: multiTheme || DEFAULT_THEMES,
-    } as CodeOptionsMultipleThemes<BundledTheme>;
-  }
-
-  return {
-    theme: singleTheme || DEFAULT_THEMES.dark,
-  } as CodeOptionsSingleTheme<BundledTheme>;
-};
-
 export const buildShikiOptions = <F extends OutputFormat>(
   languageId: string,
-  themeResult: ThemeResult,
+  themeResolution: ThemeResolution,
   options: HighlighterOptions<F>
 ): CodeToHastOptions => {
   const {
@@ -51,23 +24,20 @@ export const buildShikiOptions = <F extends OutputFormat>(
     ...restOptions
   } = options;
 
-  const themeOptions = buildThemeOptions(themeResult);
-  const multiThemeOptions = themeResult.isMultiTheme
-    ? { defaultColor, cssVariablePrefix }
-    : {};
-
   const transformers = [...(restOptions.transformers || [])];
   if (showLineNumbers && outputFormat !== 'tokens') {
     transformers.push(lineNumbersTransformer(startingLineNumber));
   }
 
   return {
     lang: languageId,
-    ...themeOptions,
-    ...multiThemeOptions,
+    ...toShikiOptions(themeResolution),
+    ...getMultiThemeOptions(
+      themeResolution,
+      defaultColor,
+      cssVariablePrefix
+    ),
     ...restOptions,
     transformers,
   };
 };
-
-export { DEFAULT_THEMES };