chore: wip

Author: chrisbbreuer

README.md

@@ -180,10 +180,10 @@ const langFromExt = getLanguageByExtension('.jsx') // Returns JavaScript languag
 
 ```typescript
 interface Token {
-  type: string        // Token scope (e.g., 'keyword.control.js', 'string.quoted.double.ts')
-  content: string     // The actual text content
-  line: number        // Line number (0-indexed)
-  startIndex: number  // Character position in the line
+  type: string // Token scope (e.g., 'keyword.control.js', 'string.quoted.double.ts')
+  content: string // The actual text content
+  line: number // Line number (0-indexed)
+  startIndex: number // Character position in the line
 }
 
 interface LineTokens {

docs/advanced/batch-processing.md

@@ -16,8 +16,8 @@ When processing multiple files, batch processing provides:
 ### Processing Multiple Files
 
 ```typescript
-import { Tokenizer } from 'ts-syntax-highlighter'
 import fs from 'node:fs/promises'
+import { Tokenizer } from 'ts-syntax-highlighter'
 
 async function processFiles(files: string[], language: string) {
   const tokenizer = new Tokenizer(language)
@@ -44,7 +44,7 @@ async function processFilesParallel(files: string[], language: string) {
   const tokenizer = new Tokenizer(language)
 
   const results = await Promise.all(
-    files.map(async file => {
+    files.map(async (file) => {
       const code = await fs.readFile(file, 'utf-8')
       const tokens = await tokenizer.tokenizeAsync(code)
       return { file, tokens }
@@ -74,13 +74,15 @@ async function processWithConcurrency(
 
   async function processNext(): Promise<void> {
     const file = queue.shift()
-    if (!file) return
+    if (!file)
+      return
 
     try {
       const code = await fs.readFile(file, 'utf-8')
       const tokens = await tokenizer.tokenizeAsync(code)
       results.set(file, tokens)
-    } catch (error) {
+    }
+    catch (error) {
       console.error(`Failed to process ${file}:`, error)
       results.set(file, null)
     }
@@ -129,13 +131,14 @@ async function batchProcess(
     const batch = files.slice(i, i + config.concurrency)
 
     const batchResults = await Promise.all(
-      batch.map(async file => {
+      batch.map(async (file) => {
         try {
           const code = await fs.readFile(file, 'utf-8')
           const tokens = await tokenizer.tokenizeAsync(code)
           config.onSuccess?.(file)
           return { file, tokens, error: null }
-        } catch (error) {
+        }
+        catch (error) {
           config.onError?.(file, error as Error)
           return { file, tokens: null, error: error as Error }
         }
@@ -183,12 +186,13 @@ async function processWithRetry(
     try {
       const code = await fs.readFile(file, 'utf-8')
       return await tokenizer.tokenizeAsync(code)
-    } catch (error) {
+    }
+    catch (error) {
       lastError = error as Error
       if (attempt < maxRetries - 1) {
         // Wait before retry (exponential backoff)
         await new Promise(resolve =>
-          setTimeout(resolve, Math.pow(2, attempt) * 100)
+          setTimeout(resolve, 2 ** attempt * 100)
         )
       }
     }
@@ -205,11 +209,12 @@ async function batchProcessWithRetry(
   const tokenizer = new Tokenizer(language)
   const results = new Map()
 
-  const promises = files.map(async file => {
+  const promises = files.map(async (file) => {
     try {
       const tokens = await processWithRetry(file, tokenizer, maxRetries)
       results.set(file, { success: true, tokens })
-    } catch (error) {
+    }
+    catch (error) {
       results.set(file, { success: false, error: error as Error })
     }
   })
@@ -315,7 +320,7 @@ async function processInChunks(
     const chunk = files.slice(i, i + chunkSize)
 
     const chunkResults = await Promise.all(
-      chunk.map(async file => {
+      chunk.map(async (file) => {
         const code = await fs.readFile(file, 'utf-8')
         return {
           file,
@@ -327,7 +332,8 @@ async function processInChunks(
     allResults.push(...chunkResults)
 
     // Force garbage collection between chunks
-    if (global.gc) global.gc()
+    if (global.gc)
+      global.gc()
   }
 
   return allResults
@@ -352,7 +358,7 @@ async function processProject(
 
   // Group by language
   const byLanguage = new Map<string, string[]>()
-  files.forEach(file => {
+  files.forEach((file) => {
     const ext = file.split('.').pop()
     const lang = ext === 'ts' || ext === 'tsx' ? 'typescript' : 'javascript'
 
@@ -413,8 +419,8 @@ async function generateStats(files: string[], language: string): Promise<Stats>
     stats.totalFiles++
     stats.totalLines += tokens.length
 
-    tokens.forEach(line => {
-      line.tokens.forEach(token => {
+    tokens.forEach((line) => {
+      line.tokens.forEach((token) => {
         stats.totalTokens++
 
         // Count by type

docs/advanced/custom-themes.md

@@ -8,12 +8,12 @@ ts-syntax-highlighter uses TextMate-style scope names to classify tokens:
 
 ```typescript
 // Example token scopes
-'keyword.control.js'              // if, for, while, return
-'storage.type.js'                 // const, let, var, function
-'string.quoted.double.js'         // "string"
-'constant.numeric.js'             // 42, 3.14
-'entity.name.function.js'         // function names
-'comment.line.double-slash.js'    // // comments
+'keyword.control.js' // if, for, while, return
+'storage.type.js' // const, let, var, function
+'string.quoted.double.js' // "string"
+'constant.numeric.js' // 42, 3.14
+'entity.name.function.js' // function names
+'comment.line.double-slash.js' // // comments
 ```
 
 ## Scope Hierarchy
@@ -53,8 +53,8 @@ function extractScopes(code: string, language: string): Set<string> {
   const tokens = tokenizer.tokenize(code)
   const scopes = new Set<string>()
 
-  tokens.forEach(line => {
-    line.tokens.forEach(token => {
+  tokens.forEach((line) => {
+    line.tokens.forEach((token) => {
       scopes.add(token.type)
     })
   })
@@ -138,34 +138,46 @@ const lightPalette: ThemePalette = {
 ```typescript
 function scopeToColor(scope: string, palette: ThemePalette): string {
   // Keyword scopes
-  if (scope.includes('keyword.control')) return palette.keyword
-  if (scope.includes('keyword.operator')) return palette.operator
+  if (scope.includes('keyword.control'))
+    return palette.keyword
+  if (scope.includes('keyword.operator'))
+    return palette.operator
 
   // Storage scopes
-  if (scope.includes('storage.type')) return palette.storage
+  if (scope.includes('storage.type'))
+    return palette.storage
 
   // String scopes
-  if (scope.includes('string.quoted')) return palette.string
-  if (scope.includes('string.template')) return palette.string
+  if (scope.includes('string.quoted'))
+    return palette.string
+  if (scope.includes('string.template'))
+    return palette.string
 
   // Number scopes
-  if (scope.includes('constant.numeric')) return palette.number
+  if (scope.includes('constant.numeric'))
+    return palette.number
 
   // Function scopes
-  if (scope.includes('entity.name.function')) return palette.function
+  if (scope.includes('entity.name.function'))
+    return palette.function
 
   // Comment scopes
-  if (scope.includes('comment')) return palette.comment
+  if (scope.includes('comment'))
+    return palette.comment
 
   // Type scopes
-  if (scope.includes('entity.name.type')) return palette.type
-  if (scope.includes('storage.type')) return palette.type
+  if (scope.includes('entity.name.type'))
+    return palette.type
+  if (scope.includes('storage.type'))
+    return palette.type
 
   // Constant scopes
-  if (scope.includes('constant.language')) return palette.constant
+  if (scope.includes('constant.language'))
+    return palette.constant
 
   // Variable scopes
-  if (scope.includes('variable')) return palette.variable
+  if (scope.includes('variable'))
+    return palette.variable
 
   // Default
   return palette.foreground
@@ -185,7 +197,7 @@ function generateThemeCSS(palette: ThemePalette, scopes: Set<string>): string {
   css += `}\n\n`
 
   // Generate rules for each scope
-  Array.from(scopes).sort().forEach(scope => {
+  Array.from(scopes).sort().forEach((scope) => {
     const className = scope.replace(/\./g, '-')
     const color = scopeToColor(scope, palette)
 
@@ -211,8 +223,8 @@ fs.writeFileSync('theme.css', css)
 
 ```typescript
 const vscDarkTheme = {
-  background: '#1e1e1e',
-  foreground: '#d4d4d4',
+  'background': '#1e1e1e',
+  'foreground': '#d4d4d4',
 
   // Comments
   'comment.line': '#6a9955',
@@ -258,8 +270,8 @@ const vscDarkTheme = {
 
 ```typescript
 const githubLightTheme = {
-  background: '#ffffff',
-  foreground: '#24292e',
+  'background': '#ffffff',
+  'foreground': '#24292e',
 
   // Comments
   'comment.line': '#6a737d',
@@ -320,14 +332,15 @@ function highlightWithTheme(
   html += `border-radius: 4px;`
   html += '"><code>'
 
-  tokens.forEach(line => {
-    line.tokens.forEach(token => {
+  tokens.forEach((line) => {
+    line.tokens.forEach((token) => {
       const color = findColorForScope(token.type, theme)
       const escaped = escapeHtml(token.content)
 
       if (color) {
         html += `<span style="color: ${color}">${escaped}</span>`
-      } else {
+      }
+      else {
         html += escaped
       }
     })
@@ -343,13 +356,15 @@ function findColorForScope(
   theme: Record<string, string>
 ): string | null {
   // Exact match
-  if (theme[scope]) return theme[scope]
+  if (theme[scope])
+    return theme[scope]
 
   // Partial match (most specific first)
   const parts = scope.split('.')
   for (let i = parts.length; i > 0; i--) {
     const partial = parts.slice(0, i).join('.')
-    if (theme[partial]) return theme[partial]
+    if (theme[partial])
+      return theme[partial]
   }
 
   return null
@@ -373,8 +388,8 @@ function highlightWithClasses(code: string, language: string): string {
 
   let html = '<pre><code>'
 
-  tokens.forEach(line => {
-    line.tokens.forEach(token => {
+  tokens.forEach((line) => {
+    line.tokens.forEach((token) => {
       const className = token.type.replace(/\./g, '-')
       const escaped = escapeHtml(token.content)
       html += `<span class="${className}">${escaped}</span>`
@@ -419,12 +434,16 @@ const advancedTheme: Record<string, TokenStyle> = {
 
 function applyAdvancedStyle(scope: string): string {
   const style = advancedTheme[scope]
-  if (!style) return ''
+  if (!style)
+    return ''
 
   let css = `color: ${style.color};`
-  if (style.fontWeight) css += ` font-weight: ${style.fontWeight};`
-  if (style.fontStyle) css += ` font-style: ${style.fontStyle};`
-  if (style.textDecoration) css += ` text-decoration: ${style.textDecoration};`
+  if (style.fontWeight)
+    css += ` font-weight: ${style.fontWeight};`
+  if (style.fontStyle)
+    css += ` font-style: ${style.fontStyle};`
+  if (style.textDecoration)
+    css += ` text-decoration: ${style.textDecoration};`
 
   return css
 }
@@ -436,9 +455,12 @@ function applyAdvancedStyle(scope: string): string {
 function getSemanticColor(token: Token, context: Context): string {
   // Color based on context
   if (token.type.includes('variable')) {
-    if (context.isParameter) return '#9cdcfe'
-    if (context.isConstant) return '#4fc1ff'
-    if (context.isGlobal) return '#4ec9b0'
+    if (context.isParameter)
+      return '#9cdcfe'
+    if (context.isConstant)
+      return '#4fc1ff'
+    if (context.isGlobal)
+      return '#4ec9b0'
     return '#9cdcfe'
   }
 
@@ -452,12 +474,12 @@ function getSemanticColor(token: Token, context: Context): string {
 
 ```typescript
 import {
-  vscDarkTheme,
-  githubLightTheme,
   draculaTheme,
+  githubLightTheme,
   monokaiTheme,
   solarizedDarkTheme,
-  solarizedLightTheme
+  solarizedLightTheme,
+  vscDarkTheme
 } from 'ts-syntax-highlighter/themes'
 
 // Apply theme