### Install jq Dependency

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Update-Languages.md

Install the required jq utility via Homebrew.

```bash
$ brew install jq
```

--------------------------------

### Build Tree-sitter Framework

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Executes a shell script to build the xcframework for the Tree-sitter language parser. Debugging can be enabled with the `--debug` flag. Ensure `jq` is installed.

```bash
$ ./build_framework.sh

```

```bash
$ brew install jq

```

```bash
$ ./build_framework.sh --debug

```

--------------------------------

### Get Tree-sitter Query for Swift

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/TreeSitterModel.md

Fetches the Tree-sitter query for a specific language ID. This operation can be expensive.

```swift
let language = CodeLanguage.swift

// this call might be expensive
let query = TreeSitterModel.shared.query(for: language.id)
```

--------------------------------

### GET /detectLanguageFrom

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/CodeLanguage.md

Detects the programming language of a file based on its URL extension.

```APIDOC
## GET detectLanguageFrom(url:)

### Description
Detects the appropriate CodeLanguage for a given file URL based on its extension. If the language is not supported, it returns the default (plain text) language.

### Method
Static Method

### Parameters
#### Path Parameters
- **url** (URL) - Required - The file system URL of the file to analyze.

### Response
- **CodeLanguage** - The detected language object.
```

--------------------------------

### Access Swift Tree-sitter Query Directly

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/TreeSitterModel.md

Directly accesses the cached Tree-sitter query for Swift. This is a convenient way to get the query if you know the language.

```swift
// this call might be expensive
let query = TreeSitterModel.shared.swiftQuery
```

--------------------------------

### Navigate to Project Directory

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Update-Languages.md

Set the working directory to the CodeEditLanguages project path.

```bash
$ cd path/to/CodeEditLanguages
```

--------------------------------

### Use Tree-sitter Queries for Parsing

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Shows how to use a Tree-sitter query with a parser to analyze code. This involves setting up the parser, parsing source code, and iterating through query matches.

```swift
let language = CodeLanguage.swift
if let treeSitterLang = language.language,
   let query = TreeSitterModel.shared.query(for: language.id) {

    let parser = Parser()
    try parser.setLanguage(treeSitterLang)

    let source = """
    func greet(name: String) {
        print("Hello, \(name)!")
    }
    """

    if let tree = parser.parse(source) {
        let cursor = query.execute(node: tree.rootNode!, in: tree)

        while let match = cursor.next() {
            for capture in match.captures {
                print("Capture: \(capture.name ?? "unnamed") at \(capture.node.range)")
            }
        }
    }
}
```

--------------------------------

### Implementing unit tests for a new language

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Create test cases to verify language detection and query loading.

```swift
// MARK: - Swift

    // create as many test cases as there are file extensions
    func test_CodeLanguageSwift() throws {
        let url = URL(fileURLWithPath: "~/path/to/file.swift")
        let language = CodeLanguage.detectLanguageFrom(url: url)

        XCTAssertEqual(language.id, .swift)
    }

    func test_FetchQuerySwift() throws {
        var language = CodeLanguage.swift
        language.resourceURL = bundleURL

        let data = try Data(contentsOf: language.queryURL!)
        let query = try? Query(language: language.language!, data: data)
        XCTAssertNotNil(query)
        XCTAssertNotEqual(query?.patternCount, 0)
    }
```

--------------------------------

### Build Framework

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Update-Languages.md

Execute the build script to update artifacts, optionally with debug logging.

```bash
$ ./build_framework.sh
```

```bash
$ ./build_framework.sh --debug
```

--------------------------------

### Implement Syntax Highlighting with SwiftTreeSitter

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Use the TreeSitterModel singleton to parse source code and extract syntax highlights based on detected language.

```swift
import CodeEditLanguages
import SwiftTreeSitter
import Foundation

class SyntaxHighlighter {
    private let model = TreeSitterModel.shared

    func highlight(source: String, fileURL: URL) -> [(range: Range<String.Index>, capture: String)] {
        var highlights: [(range: Range<String.Index>, capture: String)] = []

        // Detect language from file URL
        let codeLanguage = CodeLanguage.detectLanguageFrom(url: fileURL)

        // Skip if plain text or no language support
        guard codeLanguage.id != .plainText,
              let language = codeLanguage.language,
              let query = model.query(for: codeLanguage.id) else {
            return highlights
        }

        // Create parser and parse source
        let parser = Parser()
        do {
            try parser.setLanguage(language)
        } catch {
            print("Failed to set language: \(error)")
            return highlights
        }

        guard let tree = parser.parse(source) else {
            return highlights
        }

        // Execute query and collect captures
        let cursor = query.execute(node: tree.rootNode!, in: tree)

        while let match = cursor.next() {
            for capture in match.captures {
                let startIndex = source.index(source.startIndex, offsetBy: Int(capture.node.startByte))
                let endIndex = source.index(source.startIndex, offsetBy: Int(capture.node.endByte))

                if let captureName = capture.name {
                    highlights.append((range: startIndex..<endIndex, capture: captureName))
                }
            }
        }

        return highlights
    }
}

// Usage example
let highlighter = SyntaxHighlighter()
let source = """
func main() {
    let message = "Hello, World!"
    print(message)
}
"""

let fileURL = URL(fileURLWithPath: "main.swift")
let highlights = highlighter.highlight(source: source, fileURL: fileURL)

for (range, capture) in highlights {
    print("\(capture): \"\(source[range])\"")
}
// Example output:
// keyword: "func"
// function: "main"
// keyword: "let"
// variable: "message"
// string: "\"Hello, World!\""
// function: "print"
// variable: "message"
```

--------------------------------

### Access TreeSitterModel Singleton and Queries

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Demonstrates accessing the shared TreeSitterModel singleton to retrieve language-specific tree-sitter queries. Queries are loaded lazily on first access.

```swift
import CodeEditLanguages
import SwiftTreeSitter

// Access the shared singleton
let model = TreeSitterModel.shared

// Get a query for a specific language by ID
if let swiftQuery = model.query(for: .swift) {
    print("Swift query pattern count: \(swiftQuery.patternCount)")
}

// Access queries directly via typed properties (lazily loaded)
if let pythonQuery = TreeSitterModel.shared.pythonQuery {
    print("Python query loaded with \(pythonQuery.patternCount) patterns")
}
```

--------------------------------

### TreeSitterModel Usage

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/TreeSitterModel.md

Demonstrates how to access Tree-sitter queries for different languages using the shared instance of TreeSitterModel.

```APIDOC
## TreeSitterModel Usage

### Description
This section shows how to obtain Tree-sitter queries for programming languages. Queries are fetched lazily and cached for the session.

### Method
Static access via shared instance.

### Endpoint
N/A (In-memory model)

### Parameters
N/A

### Request Example
```swift
let language = CodeLanguage.swift

// this call might be expensive
let query = TreeSitterModel.shared.query(for: language.id)
```
Or access it directly
```swift
// this call might be expensive
let query = TreeSitterModel.shared.swiftQuery
```

### Response
#### Success Response (200)
Returns a Tree-sitter query object for the specified language.

#### Response Example
N/A (Direct object return)
```

--------------------------------

### Configure Package.swift for Tree-sitter

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Defines the SPM package for a Tree-sitter language parser. Ensure to exclude unnecessary files and include necessary sources and resources. Replace `{LANG}` with the specific language identifier.

```swift
// swift-tools-version:5.3
import PackageDescription

let package = Package(
    name: "TreeSitter{LANG}",
    platforms: [.macOS(.v10_13), .iOS(.v11)],
    products: [
        .library(name: "TreeSitter{LANG}", targets: ["TreeSitter{LANG}"]),
    ],
    dependencies: [],
    targets: [
        .target(name: "TreeSitter{LANG}",
                path: ".",
                exclude: [
                    "binding.gyp",
                    "bindings",
                    "Cargo.toml",
                    "corpus",
                    "examples",
                    "grammar.js",
                    "LICENSE",
                    "Makefile",
                    "package.json",
                    "README.md",
                    "src/grammar.json",
                    "src/node-types.json",
                    // any additional files to exclude 
                ],
                sources: [
                    "src/parser.c",
                    "src/scanner.cc", // this might be `scanner.c` or not present at all
                ],
                resources: [
                    .copy("queries")
                ],
                publicHeadersPath: "bindings/swift",
                cSettings: [.headerSearchPath("src")])
    ]
)

```

--------------------------------

### Handling Documentation Comment Syntax

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Explains how the `DocumentationComments` enum represents documentation comment syntax for various languages, including single-line and paired styles. It also shows how to check for and use this information.

```swift
import CodeEditLanguages

// Languages with documentation comment support
let rustLang = CodeLanguage.rust
print(rustLang.documentationCommentStrings)
// Contains: .single("///"), .single("//!'), .pair(("/**", "*/")), .pair(("/*!", "*/"))

let swiftLang = CodeLanguage.swift
print(swiftLang.documentationCommentStrings)
// Contains: .single("///"), .pair(("/**", "*/"))

let pythonLang = CodeLanguage.python
print(pythonLang.documentationCommentStrings)
// Contains: .pair(("\"\"\"", "\"\"\""))

// Check for documentation comment support
for lang in CodeLanguage.allLanguages {
    if !lang.documentationCommentStrings.isEmpty {
        print("\(lang.tsName) supports documentation comments")
    }
}

// Use documentation comments info for editor features
let language = CodeLanguage.java
for docComment in language.documentationCommentStrings {
    switch docComment {
    case .single(let prefix):
        print("Single-line doc comment: \(prefix)")
    case .pair(let (start, end)):
        print("Multi-line doc comment: \(start) ... \(end)")
    }
}
// Output: Multi-line doc comment: /** ... */
```

--------------------------------

### Iterating and Filtering Supported Languages

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Use the allLanguages property to list available languages or filter them based on specific file extensions.

```swift
import CodeEditLanguages

// Get all supported languages
let languages = CodeLanguage.allLanguages
print("Supported languages: \(languages.count)")

// List all language names and their extensions
for lang in CodeLanguage.allLanguages {
    print("\(lang.tsName): \(lang.extensions.joined(separator: ", "))")
}

// Example output:
// agda: agda
// bash: sh, bash
// c: c, h
// cpp: cc, cpp, c++, hpp, h
// swift: swift
// ...

// Find languages that support a specific file extension
let jsExtensions = ["js", "cjs", "mjs"]
let jsLanguages = CodeLanguage.allLanguages.filter { lang in
    !lang.extensions.intersection(Set(jsExtensions)).isEmpty
}
// Returns: [CodeLanguage.javascript]
```

--------------------------------

### Create Tree-sitter Language Header

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Defines the C header file for exposing the tree-sitter language parsing function. This is required for Swift bindings. Replace `{LANG}` with the language identifier.

```c++
#ifndef TREE_SITTER_{LANG}_H_
#define TREE_SITTER_{LANG}_H_

typedef struct TSLanguage TSLanguage;

#ifdef __cplusplus
extern "C" {
#endif

extern TSLanguage *tree_sitter_{lang}();

#ifdef __cplusplus
}
#endif

#endif // TREE_SITTER_{LANG}_H_

```

--------------------------------

### Accessing CodeLanguage Metadata

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Retrieve language definitions, file extensions, comment syntax, and tree-sitter query URLs using the CodeLanguage struct.

```swift
import CodeEditLanguages

// Direct access to a language definition
let swiftLanguage = CodeLanguage.swift

// Access language properties
print(swiftLanguage.id)                    // TreeSitterLanguage.swift
print(swiftLanguage.tsName)                // "swift"
print(swiftLanguage.extensions)            // ["swift"]
print(swiftLanguage.lineCommentString)     // "//"
print(swiftLanguage.rangeCommentStrings)   // ("/*", "*/")

// Get the tree-sitter Language object for parsing
if let language = swiftLanguage.language {
    print("Tree-sitter language available")
}

// Get the query URL for syntax highlighting
if let queryURL = swiftLanguage.queryURL {
    let highlightData = try Data(contentsOf: queryURL)
    print("Loaded \(highlightData.count) bytes of highlight queries")
}
```

--------------------------------

### TreeSitterModel Properties

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/TreeSitterModel.md

Lists the available properties for accessing Tree-sitter queries directly for each supported language.

```APIDOC
## TreeSitterModel Instance Properties

### Description
Direct access to pre-fetched Tree-sitter queries for various programming languages.

### Method
Instance property access.

### Endpoint
N/A (In-memory model)

### Parameters
N/A

### Request Example
```swift
let swiftQuery = TreeSitterModel.shared.swiftQuery
let pythonQuery = TreeSitterModel.shared.pythonQuery
```

### Response
#### Success Response (200)
Returns a Tree-sitter query object for the specified language.

#### Response Example
N/A (Direct object return)

### Available Properties
- `bashQuery`
- `cQuery`
- `cppQuery`
- `cSharpQuery`
- `cssQuery`
- `dartQuery`
- `dockerfileQuery`
- `elixirQuery`
- `goQuery`
- `goModQuery`
- `haskellQuery`
- `htmlQuery`
- `javaQuery`
- `javascriptQuery`
- `jsdocQuery`
- `jsonQuery`
- `jsxQuery`
- `kotlinQuery`
- `luaQuery`
- `markdownQuery`
- `markdownInlineQuery`
- `objcQuery`
- `ocamlQuery`
- `ocamlInterfaceQuery`
- `phpQuery`
- `pythonQuery`
- `rubyQuery`
- `rustQuery`
- `scalaQuery`
- `sqlQuery`
- `swiftQuery`
- `tomlQuery`
- `yamlQuery`
- `zigQuery`
```

--------------------------------

### Defining the CodeLanguage constant

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Define the static constant for the new language, including its ID, name, and file extensions.

```swift
static let {lang}: CodeLanguage = .init(
    id: .{lang}, 
    tsName: {lang}, 
    extensions: [...]
)
```

--------------------------------

### Detecting Languages from URLs and Content

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Automatically identify programming languages using file extensions, shebang lines, or editor modelines.

```swift
import CodeEditLanguages
import Foundation

// Basic detection from file extension
let swiftURL = URL(fileURLWithPath: "/path/to/file.swift")
let language = CodeLanguage.detectLanguageFrom(url: swiftURL)
print(language.id)  // .swift

// Detection for files without extension (e.g., Dockerfile)
let dockerURL = URL(fileURLWithPath: "/path/to/Dockerfile")
let dockerLang = CodeLanguage.detectLanguageFrom(url: dockerURL)
print(dockerLang.id)  // .dockerfile

// Detection from shebang (useful for extensionless scripts)
let unknownURL = URL(fileURLWithPath: "/path/to/script")
let shebangContent = "#!/usr/bin/env python3\nimport sys\n"
let pythonLang = CodeLanguage.detectLanguageFrom(
    url: unknownURL,
    prefixBuffer: shebangContent
)
print(pythonLang.id)  // .python

// Detection from Vim modeline
let fileContent = "// vim: ft=swift ts=4 sw=4 et:\nlet x = 1"
let vimLang = CodeLanguage.detectLanguageFrom(
    url: URL(fileURLWithPath: "/path/to/file"),
    prefixBuffer: fileContent
)
print(vimLang.id)  // .swift

// Detection from Emacs modeline
let emacsContent = "-*- mode: javascript; indent-tabs-mode: nil -*-"
let emacsLang = CodeLanguage.detectLanguageFrom(
    url: URL(fileURLWithPath: "/path/to/file"),
    prefixBuffer: emacsContent
)
print(emacsLang.id)  // .javascript

// Fallback to plain text for unsupported files
let unknownFile = URL(fileURLWithPath: "/path/to/file.xyz")
let fallbackLang = CodeLanguage.detectLanguageFrom(url: unknownFile)
print(fallbackLang.id)  // .plainText
```

--------------------------------

### Detect Language from File Extension

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/CodeLanguage.md

Detect the programming language of a file by providing its URL. If the language is not supported, it defaults to plain text.

```swift
let fileURL = URL(fileURLWithPath: "/path/to/file.swift")
let language = CodeLanguage.detectLanguageFrom(url: fileURL)
```

--------------------------------

### Add CodeEditLanguages as a Swift Package Dependency

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Include the package in your Package.swift file to access precompiled tree-sitter grammars.

```swift
// In Package.swift
import PackageDescription

let package = Package(
    name: "MyCodeEditor",
    platforms: [.macOS(.v13)],
    dependencies: [
        .package(
            url: "https://github.com/CodeEditApp/CodeEditLanguages.git",
            from: "0.1.0"
        )
    ],
    targets: [
        .target(
            name: "MyCodeEditor",
            dependencies: ["CodeEditLanguages"]
        )
    ]
)
```

--------------------------------

### CodeLanguage Structure

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Provides access to metadata for each supported programming language, including file extensions, comment strings, and tree-sitter language references.

```APIDOC
## CodeLanguage Structure

### Description
The `CodeLanguage` struct holds metadata for each supported programming language, including file extensions, comment strings, and tree-sitter language references. It provides both direct access to language definitions via static properties and automatic language detection from file URLs.

### Request Example
```swift
import CodeEditLanguages

// Direct access to a language definition
let swiftLanguage = CodeLanguage.swift

// Access language properties
print(swiftLanguage.id)                    // TreeSitterLanguage.swift
print(swiftLanguage.tsName)                // "swift"
print(swiftLanguage.extensions)            // ["swift"]
print(swiftLanguage.lineCommentString)     // "//"
print(swiftLanguage.rangeCommentStrings)   // ("/*", "*/")

// Get the tree-sitter Language object for parsing
if let language = swiftLanguage.language {
    print("Tree-sitter language available")
}

// Get the query URL for syntax highlighting
if let queryURL = swiftLanguage.queryURL {
    let highlightData = try Data(contentsOf: queryURL)
    print("Loaded \(highlightData.count) bytes of highlight queries")
}
```

### Response Example
```
TreeSitterLanguage.swift
swift
swift
//
/*
*/
Tree-sitter language available
Loaded 1234 bytes of highlight queries
```
```

--------------------------------

### Type Properties: CodeLanguage

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/CodeLanguage.md

Accessing supported languages via static type properties.

```APIDOC
## Type Properties

### Description
Access predefined CodeLanguage instances for supported languages (e.g., CodeLanguage.swift, CodeLanguage.python).

### Supported Languages
- Agda, Bash, C, C++, C#, CSS, Dart, Dockerfile, Elixir, Go, Go Mod, Haskell, HTML, Java, JavaScript, JSON, JSX, Julia, Kotlin, Lua, Markdown, Objective C, OCaml, Perl, PHP, Python, Ruby, Rust, Scala, SQL, Swift, TOML, Verilog, YAML, Zig.
```

--------------------------------

### CodeLanguage.allLanguages

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Accesses an array of all supported language definitions, useful for iterating or building language selection UIs.

```APIDOC
## CodeLanguage.allLanguages

### Description
The `allLanguages` static property provides access to an array of all supported language definitions. This is useful for iterating over available languages or building language selection UIs.

### Request Example
```swift
import CodeEditLanguages

// Get all supported languages
let languages = CodeLanguage.allLanguages
print("Supported languages: \(languages.count)")

// List all language names and their extensions
for lang in CodeLanguage.allLanguages {
    print("\(lang.tsName): \(lang.extensions.joined(separator: ", "))")
}

// Find languages that support a specific file extension
let jsExtensions = ["js", "cjs", "mjs"]
let jsLanguages = CodeLanguage.allLanguages.filter {
    !$0.extensions.intersection(Set(jsExtensions)).isEmpty
}
// Returns: [CodeLanguage.javascript]
```

### Response Example
```
Supported languages: 35
agda: agda
bash: sh, bash
c: c, h
cpp: cc, cpp, c++, hpp, h
swift: swift
...
```
```

--------------------------------

### Adding language to allLanguages array

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Include the new language in the allLanguages static array.

```swift
static let allLanguages: [CodeLanguage] = [
    // other languages
    .{lang},
    // other languages
]
```

--------------------------------

### Access Swift Language

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/CodeLanguage.md

Access a specific language like Swift directly using its type property.

```swift
let language = CodeLanguage.swift
```

--------------------------------

### Creating a TreeSitterModel query

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Define a lazy query property for the new language in TreeSitterModel.swift.

```swift
public private(set) lazy var {lang}Query: Query? = {
    return queryFor(.{lang})
}()
```

--------------------------------

### Check Git Status

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Update-Languages.md

Verify if Package.resolved has changed after updating dependencies.

```bash
$ git status
```

--------------------------------

### Updating the query method in TreeSitterModel

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Add a case to the query(for:) method to return the language-specific query.

```swift
public func query(for language: TreeSitterLanguage) -> Query? {
    switch language {
    // other cases
    case .{lang}:
        return {lang}Query
    // other cases
    }
}
```

--------------------------------

### CodeLanguage.detectLanguageFrom

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Automatically detects the programming language from a file URL, optionally using file content for shebang or modeline detection.

```APIDOC
## CodeLanguage.detectLanguageFrom(url:prefixBuffer:suffixBuffer:)

### Description
This static method automatically detects the programming language from a file URL, optionally using file content for shebang or modeline detection. It first attempts to match by file extension, then falls back to shebang parsing and modeline detection.

### Parameters
#### Path Parameters
- **url** (URL) - Required - The URL of the file to detect the language for.
- **prefixBuffer** (String?) - Optional - The content of the file to use for shebang or modeline detection.
- **suffixBuffer** (String?) - Optional - Additional content for detection (less common).

### Request Example
```swift
import CodeEditLanguages
import Foundation

// Basic detection from file extension
let swiftURL = URL(fileURLWithPath: "/path/to/file.swift")
let language = CodeLanguage.detectLanguageFrom(url: swiftURL)
print(language.id)  // .swift

// Detection for files without extension (e.g., Dockerfile)
let dockerURL = URL(fileURLWithPath: "/path/to/Dockerfile")
let dockerLang = CodeLanguage.detectLanguageFrom(url: dockerURL)
print(dockerLang.id)  // .dockerfile

// Detection from shebang (useful for extensionless scripts)
let unknownURL = URL(fileURLWithPath: "/path/to/script")
let shebangContent = "#!/usr/bin/env python3\nimport sys\n"
let pythonLang = CodeLanguage.detectLanguageFrom(
    url: unknownURL,
    prefixBuffer: shebangContent
)
print(pythonLang.id)  // .python

// Detection from Vim modeline
let fileContent = "// vim: ft=swift ts=4 sw=4 et:\nlet x = 1"
let vimLang = CodeLanguage.detectLanguageFrom(
    url: URL(fileURLWithPath: "/path/to/file"),
    prefixBuffer: fileContent
)
print(vimLang.id)  // .swift

// Detection from Emacs modeline
let emacsContent = "-*- mode: javascript; indent-tabs-mode: nil -*-"
let emacsLang = CodeLanguage.detectLanguageFrom(
    url: URL(fileURLWithPath: "/path/to/file"),
    prefixBuffer: emacsContent
)
print(emacsLang.id)  // .javascript

// Fallback to plain text for unsupported files
let unknownFile = URL(fileURLWithPath: "/path/to/file.xyz")
let fallbackLang = CodeLanguage.detectLanguageFrom(url: unknownFile)
print(fallbackLang.id)  // .plainText
```

### Response Example
```
.swift
.dockerfile
.python
.swift
.javascript
.plainText
```
```

--------------------------------

### Declare Tree-sitter Function in Header

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Adds an external declaration for the tree-sitter language function to the main header file. Ensure alphabetical order.

```c++
extern TSLanguage *tree_sitter_{lang}();

```

--------------------------------

### Registering a new language in CodeLanguage.swift

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Add the language to the tsLanguage computed property to link the Tree-sitter pointer.

```swift
private var tsLanguage: UnsafeMutablePointer<TSLanguage>? {
    switch id {
    // other cases
    case .{lang}:
        return tree_sitter_{lang}()
    }
    // other cases
}
```

--------------------------------

### Type-Safe Language Identification with TreeSitterLanguage

Source: https://context7.com/codeeditapp/codeeditlanguages/llms.txt

Illustrates using the `TreeSitterLanguage` enum for type-safe language identification and comparison. It provides enum cases for all supported languages.

```swift
import CodeEditLanguages

// Use enum cases for type-safe language identification
let languageId: TreeSitterLanguage = .swift

// Compare language IDs
let detectedLanguage = CodeLanguage.detectLanguageFrom(
    url: URL(fileURLWithPath: "main.rs")
)

switch detectedLanguage.id {
case .rust:
    print("Rust file detected")
case .swift:
    print("Swift file detected")
case .python:
    print("Python file detected")
case .plainText:
    print("Unknown file type")
default:
    print("Other language: \(detectedLanguage.id)")
}
```

--------------------------------

### Add Language Case to TreeSitterLanguage Enum

Source: https://github.com/codeeditapp/codeeditlanguages/blob/main/Sources/CodeEditLanguages/Documentation.docc/Add-Languages.md

Extends the `TreeSitterLanguage` enum in Swift to include a case for the newly added language. Replace `{lang}` with the language identifier.

```swift
// other cases
    case {lang}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.