Modular language architecture to reduce library size

Package.swift

@@ -13,6 +13,10 @@ let package = Package(
         .visionOS(.v1),
     ],
     products: [
+        /// Full library with all 19 bundled language parsers (backward-compatible).
+        .library(name: "MarkdownViewAll", targets: ["MarkdownView", "MarkdownLanguages"]),
+        /// Core rendering library without language parsers — add only the tree-sitter
+        /// languages you need and register them via `CodeHighlighter.registerLanguage`.
         .library(name: "MarkdownView", targets: ["MarkdownView"]),
         .library(name: "MarkdownParser", targets: ["MarkdownParser"]),
     ],
@@ -51,6 +55,14 @@ let package = Package(
                 "MarkdownParser",
                 "SwiftMath",
                 .product(name: "SwiftTreeSitter", package: "swift-tree-sitter"),
+            ],
+            resources: [.process("Resources")]
+        ),
+        .target(
+            name: "MarkdownLanguages",
+            dependencies: [
+                "MarkdownView",
+                .product(name: "SwiftTreeSitter", package: "swift-tree-sitter"),
                 .product(name: "TreeSitterPython", package: "tree-sitter-python"),
                 .product(name: "TreeSitterJavaScript", package: "tree-sitter-javascript"),
                 .product(name: "TreeSitterTypeScript", package: "tree-sitter-typescript"),
@@ -69,8 +81,7 @@ let package = Package(
                 .product(name: "TreeSitterKotlin", package: "tree-sitter-kotlin"),
                 .product(name: "TreeSitterSql", package: "tree-sitter-sql"),
                 .product(name: "TreeSitterYAML", package: "tree-sitter-yaml"),
-            ],
-            resources: [.process("Resources")]
+            ]
         ),
         .target(name: "MarkdownParser", dependencies: [
             .product(name: "cmark-gfm", package: "swift-cmark"),
@@ -80,6 +91,7 @@ let package = Package(
             name: "MarkdownViewTests",
             dependencies: [
                 "MarkdownView",
+                "MarkdownLanguages",
                 "MarkdownParser",
             ]
         ),

README.md

@@ -46,7 +46,49 @@ dependencies: [
 ]
 ```
 
-Then add `"MarkdownView"` as a dependency of your target.
+### All languages (default)
+
+Use the `MarkdownViewAll` product to include all 19 bundled language parsers:
+
+```swift
+.target(name: "YourApp", dependencies: [
+    .product(name: "MarkdownViewAll", package: "MarkdownView"),
+])
+```
+
+Then register the languages at app launch:
+
+```swift
+import MarkdownView
+import MarkdownLanguages
+
+// In your App.init or AppDelegate:
+MarkdownLanguages.registerAll()
+```
+
+### Core only (reduced binary size)
+
+Use the `MarkdownView` product for just the core renderer without any language parsers (~40 MB smaller):
+
+```swift
+.target(name: "YourApp", dependencies: [
+    .product(name: "MarkdownView", package: "MarkdownView"),
+])
+```
+
+Then register only the languages you need by adding their tree-sitter packages
+to your own dependencies and calling `CodeHighlighter.registerLanguage`:
+
+```swift
+import MarkdownView
+import SwiftTreeSitter
+import TreeSitterPython
+
+// Register individual languages at app launch:
+CodeHighlighter.registerLanguage(aliases: ["python", "py", "python3"]) {
+    try CodeHighlighter.makeConfig(tree_sitter_python(), name: "Python")
+}
+```
 
 ## Usage
 

Sources/MarkdownLanguages/AllLanguages.swift

@@ -0,0 +1,178 @@
+//
+//  AllLanguages.swift
+//  MarkdownView
+//
+
+import MarkdownView
+import SwiftTreeSitter
+import TreeSitterPython
+import TreeSitterJavaScript
+import TreeSitterTypeScript
+import TreeSitterTSX
+import TreeSitterGo
+import TreeSitterRust
+import TreeSitterSwift
+import TreeSitterC
+import TreeSitterCPP
+import TreeSitterJava
+import TreeSitterRuby
+import TreeSitterBash
+import TreeSitterJSON
+import TreeSitterHTML
+import TreeSitterCSS
+import TreeSitterCSharp
+import TreeSitterKotlin
+import TreeSitterSql
+import TreeSitterYAML
+
+/// Provides registration functions for all bundled tree-sitter language parsers.
+///
+/// Use ``registerAll()`` at app launch to enable syntax highlighting for all 19 languages,
+/// or call individual functions (e.g. ``registerPython()``) to include only what you need.
+public enum MarkdownLanguages {
+
+    /// Registers all 19 bundled language parsers with `CodeHighlighter`.
+    public static func registerAll() {
+        registerSwift()
+        registerPython()
+        registerJavaScript()
+        registerTypeScript()
+        registerTSX()
+        registerGo()
+        registerRust()
+        registerC()
+        registerCPP()
+        registerJava()
+        registerRuby()
+        registerBash()
+        registerJSON()
+        registerHTML()
+        registerCSS()
+        registerCSharp()
+        registerKotlin()
+        registerSQL()
+        registerYAML()
+    }
+
+    // MARK: - Individual Language Registration
+
+    public static func registerSwift() {
+        CodeHighlighter.registerLanguage(aliases: ["swift"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_swift(), name: "Swift")
+        }
+    }
+
+    public static func registerPython() {
+        CodeHighlighter.registerLanguage(aliases: ["python", "py", "python3"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_python(), name: "Python")
+        }
+    }
+
+    public static func registerJavaScript() {
+        CodeHighlighter.registerLanguage(aliases: ["javascript", "js", "jsx"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_javascript(), name: "JavaScript")
+        }
+    }
+
+    public static func registerTypeScript() {
+        CodeHighlighter.registerLanguage(aliases: ["typescript", "ts"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_typescript(), name: "TypeScript",
+                                           bundleName: "TreeSitterTypeScript_TreeSitterTypeScript")
+        }
+    }
+
+    public static func registerTSX() {
+        CodeHighlighter.registerLanguage(aliases: ["tsx"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_tsx(), name: "TSX",
+                                           bundleName: "TreeSitterTypeScript_TreeSitterTSX")
+        }
+    }
+
+    public static func registerGo() {
+        CodeHighlighter.registerLanguage(aliases: ["go", "golang"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_go(), name: "Go")
+        }
+    }
+
+    public static func registerRust() {
+        CodeHighlighter.registerLanguage(aliases: ["rust", "rs"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_rust(), name: "Rust")
+        }
+    }
+
+    public static func registerC() {
+        CodeHighlighter.registerLanguage(aliases: ["c", "h"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_c(), name: "C")
+        }
+    }
+
+    public static func registerCPP() {
+        CodeHighlighter.registerLanguage(aliases: ["cpp", "c++", "cc", "cxx", "hpp"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_cpp(), name: "CPP")
+        }
+    }
+
+    public static func registerJava() {
+        CodeHighlighter.registerLanguage(aliases: ["java"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_java(), name: "Java")
+        }
+    }
+
+    public static func registerRuby() {
+        CodeHighlighter.registerLanguage(aliases: ["ruby", "rb"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_ruby(), name: "Ruby")
+        }
+    }
+
+    public static func registerBash() {
+        CodeHighlighter.registerLanguage(aliases: ["bash", "sh", "shell", "zsh"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_bash(), name: "Bash")
+        }
+    }
+
+    public static func registerJSON() {
+        CodeHighlighter.registerLanguage(aliases: ["json", "jsonc"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_json(), name: "JSON")
+        }
+    }
+
+    public static func registerHTML() {
+        CodeHighlighter.registerLanguage(aliases: ["html", "htm"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_html(), name: "HTML")
+        }
+    }
+
+    public static func registerCSS() {
+        CodeHighlighter.registerLanguage(aliases: ["css"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_css(), name: "CSS")
+        }
+    }
+
+    public static func registerCSharp() {
+        CodeHighlighter.registerLanguage(aliases: ["csharp", "c#", "cs"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_c_sharp(), name: "CSharp",
+                                           bundleName: "TreeSitterCSharp_TreeSitterCSharp")
+        }
+    }
+
+    public static func registerKotlin() {
+        CodeHighlighter.registerLanguage(aliases: ["kotlin", "kt", "kts"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_kotlin(), name: "Kotlin",
+                                           bundleName: "TreeSitterKotlin_TreeSitterKotlin")
+        }
+    }
+
+    public static func registerSQL() {
+        CodeHighlighter.registerLanguage(aliases: ["sql"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_sql(), name: "SQL",
+                                           bundleName: "TreeSitterSql_TreeSitterSql")
+        }
+    }
+
+    public static func registerYAML() {
+        CodeHighlighter.registerLanguage(aliases: ["yaml", "yml"]) {
+            try CodeHighlighter.makeConfig(tree_sitter_yaml(), name: "YAML",
+                                           bundleName: "TreeSitterYAML_TreeSitterYAML")
+        }
+    }
+}