@xberg-io/tree-sitter-language-pack 0.0.1

package/README.md

@@ -0,0 +1,155 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://cdn.jsdelivr.net/gh/xberg-io/assets@v1/banner/readme-banner-dark.svg">
+    <img alt="Xberg" width="420" src="https://cdn.jsdelivr.net/gh/xberg-io/assets@v1/banner/readme-banner-light.svg">
+  </picture>
+</p>
+
+# TypeScript / Node.js
+
+<div align="center" style="display: flex; flex-wrap: wrap; gap: 8px; justify-content: center; margin: 20px 0">
+	<a href="https://github.com/xberg-io/alef">
+		<img src="https://img.shields.io/badge/Bindings-alef%20%D7%90-007ec6" alt="Bindings" />
+	</a>
+	<!-- Language Bindings -->
+	<a href="https://crates.io/crates/tree-sitter-language-pack">
+		<img src="https://img.shields.io/crates/v/tree-sitter-language-pack?label=Rust&color=007ec6" alt="Rust" />
+	</a>
+	<a href="https://pypi.org/project/tree-sitter-language-pack/">
+		<img src="https://img.shields.io/pypi/v/tree-sitter-language-pack?label=Python&color=007ec6" alt="Python" />
+	</a>
+	<a href="https://www.npmjs.com/package/@xberg-io/tree-sitter-language-pack">
+		<img
+			src="https://img.shields.io/npm/v/@xberg-io/tree-sitter-language-pack?label=Node.js&color=007ec6"
+			alt="Node.js"
+		/>
+	</a>
+	<a href="https://www.npmjs.com/package/@xberg-io/tree-sitter-language-pack-wasm">
+		<img
+			src="https://img.shields.io/npm/v/@xberg-io/tree-sitter-language-pack-wasm?label=WASM&color=007ec6"
+			alt="WASM"
+		/>
+	</a>
+	<a href="https://central.sonatype.com/artifact/io.xberg.treesitterlanguagepack/tree-sitter-language-pack">
+		<img
+			src="https://img.shields.io/maven-central/v/io.xberg.treesitterlanguagepack/tree-sitter-language-pack?label=Java&color=007ec6"
+			alt="Java"
+		/>
+	</a>
+	<a href="https://pkg.go.dev/github.com/xberg-io/tree-sitter-language-pack/packages/go">
+		<img
+			src="https://img.shields.io/github/v/tag/xberg-io/tree-sitter-language-pack?label=Go&color=007ec6"
+			alt="Go"
+		/>
+	</a>
+	<a href="https://www.nuget.org/packages/TreeSitterLanguagePack/">
+		<img src="https://img.shields.io/nuget/v/TreeSitterLanguagePack?label=C%23&color=007ec6" alt="C#" />
+	</a>
+	<a href="https://packagist.org/packages/xberg-io/tree-sitter-language-pack">
+		<img
+			src="https://img.shields.io/packagist/v/xberg-io/tree-sitter-language-pack?label=PHP&color=007ec6"
+			alt="PHP"
+		/>
+	</a>
+	<a href="https://rubygems.org/gems/tree_sitter_language_pack">
+		<img src="https://img.shields.io/gem/v/tree_sitter_language_pack?label=Ruby&color=007ec6" alt="Ruby" />
+	</a>
+	<a href="https://hex.pm/packages/tree_sitter_language_pack">
+		<img src="https://img.shields.io/hexpm/v/tree_sitter_language_pack?label=Elixir&color=007ec6" alt="Elixir" />
+	</a>
+	<a href="https://pub.dev/packages/tree_sitter_language_pack">
+		<img src="https://img.shields.io/pub/v/tree_sitter_language_pack?label=Dart&color=007ec6" alt="Dart" />
+	</a>
+	<a href="https://central.sonatype.com/artifact/io.xberg.tslp.android/tree-sitter-language-pack-android">
+		<img
+			src="https://img.shields.io/maven-central/v/io.xberg.tslp.android/tree-sitter-language-pack-android?label=Kotlin&color=007ec6"
+			alt="Kotlin"
+		/>
+	</a>
+	<a href="https://github.com/xberg-io/tree-sitter-language-pack/tree/main/packages/swift">
+		<img src="https://img.shields.io/badge/Swift-SPM-007ec6" alt="Swift" />
+	</a>
+	<a href="https://github.com/xberg-io/tree-sitter-language-pack/tree/main/packages/zig">
+		<img src="https://img.shields.io/badge/Zig-package-007ec6" alt="Zig" />
+	</a>
+	<a href="https://github.com/xberg-io/tree-sitter-language-pack/releases">
+		<img src="https://img.shields.io/badge/C-FFI-007ec6" alt="C FFI" />
+	</a>
+
+	<!-- Project Info -->
+	<a href="https://github.com/xberg-io/tree-sitter-language-pack/blob/main/LICENSE">
+		<img src="https://img.shields.io/badge/License-MIT-007ec6" alt="License" />
+	</a>
+	<a href="https://docs.tree-sitter-language-pack.xberg.io">
+		<img src="https://img.shields.io/badge/Docs-tree--sitter--language--pack-007ec6" alt="Documentation" />
+	</a>
+</div>
+
+<div align="center" style="display: flex; flex-wrap: wrap; gap: 12px; justify-content: center; margin: 28px 0 24px">
+	<a href="https://discord.gg/xt9WY3GnKR">
+		<img
+			height="22"
+			src="https://img.shields.io/badge/Discord-Chat-007ec6?logo=discord&logoColor=white"
+			alt="Join Discord"
+		/>
+	</a>
+</div>
+
+Pre-compiled tree-sitter grammars for 306 programming languages with TypeScript types.
+
+## What This Package Provides
+
+- **Parser access** — load a tree-sitter language parser by name without wiring individual grammar crates or packages.
+- **Code intelligence primitives** — parse trees, functions, classes, imports, exports, symbols, docstrings, diagnostics, and syntax-aware chunks.
+- **Shared cache model** — parsers are fetched and cached once, then reused by every call in the process.
+- **Same catalog as every binding** — Rust, Python, Node.js, Go, Java, PHP, Ruby, .NET, Elixir, WASM, Dart, Kotlin Android, Swift, Zig, and C FFI use the same grammar set.
+- **Node-first TypeScript API** — native NAPI package with typed parser and query helpers.
+
+## Installation
+
+```bash
+npm install @xberg-io/tree-sitter-language-pack
+```
+
+## Quick Start
+
+```typescript
+import { getParser } from "@xberg-io/tree-sitter-language-pack";
+
+const parser = getParser("python");
+const tree = parser.parse("def hello(): pass");
+console.log(tree.rootNode.toString());
+```
+
+## Features
+
+- **300+ languages** — pre-compiled tree-sitter grammars covering every major programming language and many minor ones.
+- **On-demand download + cache** — parsers fetched at first use; subsequent runs hit the local cache.
+- **Code intelligence** — extract functions, classes, imports, exports, symbols, docstrings, and diagnostics with one API.
+- **Syntax-aware chunking** — semantic chunks for RAG/LLM pipelines.
+- **Polyglot bindings** — native APIs across 15 languages: Rust, Python, TypeScript/Node.js, Go, Java, C#, Ruby, PHP, Elixir, WebAssembly, Dart, Kotlin, Swift, Zig, and C/C++ via [alef](https://github.com/xberg-io/alef).
+
+## Documentation
+
+- **[Documentation](https://docs.tree-sitter-language-pack.xberg.io)** -- Full docs and API reference
+- **[GitHub Repository](https://github.com/xberg-io/tree-sitter-language-pack)** -- Source, issues, and discussions
+
+## Part of Xberg
+
+- [Xberg](https://github.com/xberg-io/xberg) — document intelligence: text, tables, metadata from 91+ formats with optional OCR.
+- [Xberg Enterprise](https://github.com/xberg-io/xberg-enterprise) — managed extraction API with SDKs, dashboards, and observability.
+- [crawlberg](https://github.com/xberg-io/crawlberg) — web crawling and scraping with HTML→Markdown and headless-Chrome fallback.
+- [html-to-markdown](https://github.com/xberg-io/html-to-markdown) — fast, lossless HTML→Markdown engine.
+- [liter-llm](https://github.com/xberg-io/liter-llm) — universal LLM API client with native bindings for 14 languages and 143 providers.
+- [alef](https://github.com/xberg-io/alef) — the polyglot binding generator that produces this README and all per-language bindings.
+- [Discord](https://discord.gg/xt9WY3GnKR) — community, roadmap, announcements.
+
+## Contributing
+
+Contributions are welcome! See [CONTRIBUTING.md](https://github.com/xberg-io/tree-sitter-language-pack/blob/main/CONTRIBUTING.md) for guidelines.
+
+Join our [Discord community](https://discord.gg/xt9WY3GnKR) for questions and discussion.
+
+## License
+
+MIT -- see [LICENSE](https://github.com/xberg-io/tree-sitter-language-pack/blob/main/LICENSE) for details.

package/index.d.ts

@@ -0,0 +1,1025 @@
+// This file is auto-generated by alef — DO NOT EDIT.
+// alef:hash:d0b7cd41ab5c9284ea1bdf3bc59373cf38b0a5148eb158533b7694f35060156f
+// To regenerate: alef generate
+// To verify freshness: alef verify --exit-code
+/* eslint-disable */
+import type { Language } from "tree-sitter";
+
+export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
+
+/**
+ * List all available language names (sorted, deduplicated, includes aliases).
+ *
+ * Returns names of both statically compiled and dynamically loadable languages,
+ * plus any configured aliases.
+ */
+export declare function availableLanguages(): Array<string>;
+
+/**
+ * Return the effective cache directory path.
+ *
+ * This is either the custom path set via [`configure`] / [`init`] or the
+ * default: `~/.cache/tree-sitter-language-pack/v{version}/libs/`.
+ * @throws Returns an error if the system cache directory cannot be determined.
+ */
+export declare function cacheDir(): string;
+
+/**
+ * Delete all cached parser shared libraries.
+ *
+ * Resets the cache registration so the next call to [`get_language`] or
+ * a download function will re-register the (now empty) cache directory.
+ * @throws Returns an error if the cache directory cannot be removed.
+ */
+export declare function cleanCache(): void;
+
+/**
+ * Apply download configuration without downloading anything.
+ *
+ * Use this to set a custom cache directory before the first call to
+ * [`get_language`] or any download function. Changing the cache dir
+ * after languages have been registered has no effect on already-loaded
+ * languages.
+ * @throws Returns an error if the lock cannot be acquired.
+ */
+export declare function configure(config?: PackConfig | undefined | null): void;
+
+/**
+ * Detect language name from a file path or extension.
+ *
+ * This compatibility alias matches the pre-Alef Python binding API.
+ */
+export declare function detectLanguage(path: string): string | null;
+
+/**
+ * Detect language name from file content using the shebang line (`#!`).
+ *
+ * Inspects only the first line of `content`. If it begins with `#!`, the
+ * interpreter name is extracted and mapped to a language name.
+ *
+ * Handles common patterns:
+ * - `#!/usr/bin/env python3` → `"python"`
+ * - `#!/bin/bash` → `"bash"`
+ * - `#!/usr/bin/env node` → `"javascript"`
+ *
+ * The `-S` flag accepted by some `env` implementations is skipped automatically.
+ * Version suffixes (e.g. `python3.11`, `ruby3.2`) are stripped before matching.
+ *
+ * Returns `None` when content does not start with `#!`, the shebang is
+ * malformed, or the interpreter is not recognised.
+ *
+ * ```
+ * use tree_sitter_language_pack::detect_language_from_content;
+ * assert_eq!(detect_language_from_content("#!/usr/bin/env python3\npass"), Some("python"));
+ * assert_eq!(detect_language_from_content("#!/bin/bash\necho hi"), Some("bash"));
+ * assert_eq!(detect_language_from_content("no shebang here"), None);
+ * ```
+ */
+export declare function detectLanguageFromContent(content: string): string | null;
+
+/**
+ * Detect language name from a file extension (without leading dot).
+ *
+ * Returns `None` for unrecognized extensions. The match is case-insensitive.
+ *
+ * ```
+ * use tree_sitter_language_pack::detect_language_from_extension;
+ * assert_eq!(detect_language_from_extension("py"), Some("python"));
+ * assert_eq!(detect_language_from_extension("RS"), Some("rust"));
+ * assert_eq!(detect_language_from_extension("xyz"), None);
+ * ```
+ */
+export declare function detectLanguageFromExtension(ext: string): string | null;
+
+/**
+ * Detect language name from a file path.
+ *
+ * Extracts the file extension and looks it up. Returns `None` if the
+ * path has no extension or the extension is not recognized.
+ *
+ * ```
+ * use tree_sitter_language_pack::detect_language_from_path;
+ * assert_eq!(detect_language_from_path("src/main.rs"), Some("rust"));
+ * assert_eq!(detect_language_from_path("README.md"), Some("markdown"));
+ * assert_eq!(detect_language_from_path("Makefile"), None);
+ * ```
+ */
+export declare function detectLanguageFromPath(path: string): string | null;
+
+/**
+ * Download specific languages to the local cache.
+ *
+ * Returns the number of requested languages available after the call. Already
+ * compiled or cached languages are included in the count.
+ * @throws Returns an error if any language is not available in the manifest or if
+ * the download fails.
+ */
+export declare function download(names: Array<string>): number;
+
+/**
+ * Download all available languages from the remote manifest.
+ *
+ * Downloads the platform bundle and extracts every library it contains.
+ * Languages that appear in the manifest but are absent from the bundle
+ * (e.g. grammars that failed to compile at release time) are silently
+ * skipped — they are not treated as an error.
+ *
+ * Returns the total number of languages now available (statically compiled
+ * plus downloaded and cached).
+ * @throws Returns an error if the manifest cannot be fetched or the bundle download fails.
+ */
+export declare function downloadAll(): number;
+
+/**
+ * Return languages that are already downloaded and cached locally.
+ *
+ * Does not perform any network requests. Returns an empty list if the
+ * cache directory does not exist or cannot be read.
+ */
+export declare function downloadedLanguages(): Array<string>;
+
+/**
+ * Download every language in a named group (e.g. `"web"`, `"data"`).
+ *
+ * Groups are defined in the remote manifest and let you ensure a curated
+ * set of related grammars in one call instead of listing each name to
+ * [`download()`]. Already-cached languages are skipped.
+ *
+ * Returns the total number of languages now available (statically compiled
+ * plus downloaded and cached).
+ * @throws Returns an error if the manifest cannot be fetched, the group is unknown,
+ * or any constituent language fails to download.
+ */
+export declare function downloadGroup(name: string): number;
+
+/**
+ * Get the highlights query for a language, if bundled.
+ *
+ * Returns the contents of `highlights.scm` as a static string, or `None`
+ * if no highlights query is bundled for this language.
+ */
+export declare function getHighlightsQuery(language: string): string | null;
+
+/**
+ * Get the injections query for a language, if bundled.
+ *
+ * Returns the contents of `injections.scm` as a static string, or `None`
+ * if no injections query is bundled for this language.
+ */
+export declare function getInjectionsQuery(language: string): string | null;
+
+/**
+ * Get a tree-sitter [`Language`] by name using the global registry.
+ *
+ * Resolves language aliases (e.g., `"shell"` maps to `"bash"`).
+ * When the `download` feature is enabled (default), automatically downloads
+ * the parser from GitHub releases if not found locally.
+ * @throws Returns [`Error::LanguageNotFound`] if the language is not recognized,
+ * or [`Error::Download`] if auto-download fails.
+ */
+export declare function getLanguage(name: string): Language;
+
+/**
+ * Get the locals query for a language, if bundled.
+ *
+ * Returns the contents of `locals.scm` as a static string, or `None`
+ * if no locals query is bundled for this language.
+ */
+export declare function getLocalsQuery(language: string): string | null;
+
+/**
+ * Get a [`Parser`] pre-configured for the given language.
+ *
+ * This is a convenience function that calls [`get_language`] and configures
+ * a new parser in one step.
+ * @throws Returns [`Error::LanguageNotFound`] if the language is not recognized, or
+ * [`Error::ParserSetup`] if the language cannot be applied to the parser.
+ */
+export declare function getParser(name: string): Parser;
+
+/**
+ * Get the tags query for a language, if bundled.
+ *
+ * Returns the contents of `tags.scm` as a static string, or `None`
+ * if no tags query is bundled for this language.
+ */
+export declare function getTagsQuery(language: string): string | null;
+
+/**
+ * Check if a language is available by name or alias.
+ *
+ * Returns `true` if the language can be loaded (statically compiled,
+ * dynamically available, or a known alias for one of these).
+ */
+export declare function hasLanguage(name: string): boolean;
+
+/**
+ * Initialize the language pack with the given configuration.
+ *
+ * Applies any custom cache directory, then downloads all languages and groups
+ * specified in the config. This is the recommended entry point when you want
+ * to pre-warm the cache before use.
+ * @throws Returns an error if configuration cannot be applied or if downloads fail.
+ */
+export declare function init(config?: PackConfig | undefined | null): void;
+
+/** A byte range — start (inclusive) to end (exclusive). */
+export interface ByteRange {
+	/** Inclusive start byte offset. */
+	readonly start: number;
+	/** Exclusive end byte offset. */
+	readonly end: number;
+}
+
+/** Metadata for a single chunk of source code. */
+export interface ChunkContext {
+	/** Language name used to parse this chunk. */
+	readonly language?: string;
+	/** Zero-indexed position of this chunk within the file's chunk list. */
+	readonly chunkIndex?: number;
+	/** Total number of chunks the file was split into. */
+	readonly totalChunks?: number;
+	/** Tree-sitter node kinds that appear at the top level of this chunk. */
+	readonly nodeTypes?: Array<string>;
+	/** Hierarchical path of enclosing structural items (e.g., `["MyClass", "my_method"]`). */
+	readonly contextPath?: Array<string>;
+	/** Names of symbols defined within this chunk. */
+	readonly symbolsDefined?: Array<string>;
+	/** Comments contained within this chunk. */
+	readonly comments?: Array<CommentInfo>;
+	/** Docstrings contained within this chunk. */
+	readonly docstrings?: Array<DocstringInfo>;
+	/** Whether this chunk contains any tree-sitter error nodes. */
+	readonly hasErrorNodes?: boolean;
+}
+
+/** A chunk of source code with rich metadata. */
+export interface CodeChunk {
+	/** The raw source text of this chunk. */
+	readonly content?: string;
+	/** Inclusive start byte offset of this chunk in the original source. */
+	readonly startByte?: number;
+	/** Exclusive end byte offset of this chunk in the original source. */
+	readonly endByte?: number;
+	/** Zero-indexed start line of this chunk. */
+	readonly startLine?: number;
+	/** Zero-indexed end line of this chunk. */
+	readonly endLine?: number;
+	/** Contextual metadata about this chunk. */
+	readonly metadata?: ChunkContext;
+}
+
+/** A comment extracted from source code. */
+export interface CommentInfo {
+	/** The raw text content of the comment. */
+	readonly text?: string;
+	/** The kind of comment (line, block, or doc). */
+	readonly kind?: CommentKind;
+	/** Source span covering the comment. */
+	readonly span?: Span;
+	/** Name of the syntax node this comment is directly associated with. */
+	readonly associatedNode?: string;
+}
+
+/**
+ * The kind of a comment found in source code.
+ *
+ * Distinguishes between single-line comments, block (multi-line) comments,
+ * and documentation comments.
+ */
+export declare enum CommentKind {
+	/** A single-line comment (e.g., `// ...` or `# ...`). */
+	Line = "Line",
+	/** A block or multi-line comment using slash-star delimiters. */
+	Block = "Block",
+	/** A documentation comment such as `/// ...` or slash-double-star block. */
+	Doc = "Doc",
+}
+
+/**
+ * An XML-style attribute attached to an [`Element`](DataNodeKind::Element) node.
+ *
+ * Populated only for `DataNodeKind::Element`; always empty for `KeyValue` and
+ * `Sequence` nodes.
+ */
+export interface DataAttribute {
+	/** Attribute name (e.g. `"class"`, `"href"`). */
+	readonly name?: string;
+	/** Attribute value as a raw string (quotes stripped). */
+	readonly value?: string;
+	/** Source span covering the entire `name="value"` attribute token. */
+	readonly span?: Span;
+}
+
+/**
+ * A node in the hierarchical data tree produced by data-format extraction.
+ *
+ * When [`ProcessConfig::data_extraction`](crate::ProcessConfig::data_extraction) is
+ * `true`, [`ProcessResult::data`] is populated with a root `DataNode` whose
+ * [`children`](DataNode::children) mirror the structure of the parsed file.
+ *
+ * The `kind` field determines which other fields are meaningful:
+ *
+ * | `kind`     | `key`                    | `value`       | `attributes` | `children` |
+ * |------------|--------------------------|---------------|--------------|------------|
+ * | `KeyValue` | key / mapping key / index | leaf value   | empty        | nested map |
+ * | `Element`  | XML tag name             | text content  | XML attrs    | child elements |
+ * | `Sequence` | positional index (`"0"`) | leaf value   | empty        | sub-items  |
+ */
+export interface DataNode {
+	/** Whether this node is a key/value pair, XML element, or sequence item. */
+	readonly kind?: DataNodeKind;
+	/**
+	 * Key, attribute name, tag name, or positional index (`"0"`, `"1"`, …).
+	 * `None` at the document root.
+	 */
+	readonly key?: string;
+	/**
+	 * Leaf scalar value, if any. `None` for containers (objects, arrays, XML elements
+	 * with child elements).
+	 */
+	readonly value?: string;
+	/** Attributes on element-shape nodes (XML `STag` attributes). Empty for all other kinds. */
+	readonly attributes?: Array<DataAttribute>;
+	/** Children for nested containers and XML element bodies. */
+	readonly children?: Array<DataNode>;
+	/** Source span covering this node in the original source file. */
+	readonly span?: Span;
+}
+
+/**
+ * The kind of a data node extracted from a data-format file.
+ *
+ * Classifies each node in the hierarchical [`DataNode`] tree returned when
+ * `data_extraction` is enabled on `ProcessConfig`.
+ *
+ * # Wire format (public JSON contract)
+ *
+ * Unit variants serialize as a bare string (`"KeyValue"`). DO NOT add
+ * `#[serde(tag = "...")]` or rename variants — every language binding has a
+ * hand-written deserializer matching this exact shape, and any change breaks
+ * all bindings' `process()` tests simultaneously.
+ * Covered by `tests/wire_format.rs`.
+ */
+export declare enum DataNodeKind {
+	/**
+	 * A key/value pair or mapping (json/toml/properties/yaml/hcl/cue/kdl pair,
+	 * or a wrapper "object"/"mapping" container).
+	 */
+	KeyValue = "KeyValue",
+	/** An XML element with a tag name in `key` and attributes in `attributes`. */
+	Element = "Element",
+	/**
+	 * A positional sequence item (JSON array element, YAML block sequence item,
+	 * CSV/PSV row or cell).
+	 */
+	Sequence = "Sequence",
+}
+
+/** A diagnostic (syntax error, missing node, etc.) from parsing. */
+export interface Diagnostic {
+	/** Human-readable description of the diagnostic. */
+	readonly message?: string;
+	/** Severity of the diagnostic. */
+	readonly severity?: DiagnosticSeverity;
+	/** Source span where the diagnostic was detected. */
+	readonly span?: Span;
+}
+
+/**
+ * Severity level of a diagnostic produced during parsing.
+ *
+ * Used to classify parse errors, warnings, and informational messages
+ * found in the syntax tree.
+ */
+export declare enum DiagnosticSeverity {
+	/** A parse error (e.g., an `ERROR` or `MISSING` node in the tree). */
+	Error = "Error",
+	/** A warning-level diagnostic. */
+	Warning = "Warning",
+	/** An informational diagnostic. */
+	Info = "Info",
+}
+
+/** A section within a docstring (e.g., Args, Returns, Raises). */
+export interface DocSection {
+	/** Section kind (e.g., `"args"`, `"returns"`, `"raises"`). */
+	readonly kind?: string;
+	/** Parameter or return value name, if applicable. */
+	readonly name?: string;
+	/** Description text for this section. */
+	readonly description?: string;
+}
+
+/**
+ * The format of a docstring extracted from source code.
+ *
+ * Identifies the docstring convention used, which varies by language
+ * (e.g., Python triple-quoted strings, JSDoc, Rustdoc `///` comments).
+ *
+ * # Wire format (public JSON contract)
+ *
+ * Unit variants serialize as a bare string (`"JSDoc"`); the `Other`
+ * variant serializes as a single-keyed object (`{"Other": "rst"}`). DO
+ * NOT add `#[serde(tag = "...")]`. Covered by `tests/wire_format.rs`.
+ */
+export declare enum DocstringFormat {
+	/** Python triple-quoted string docstring (`"""..."""`). */
+	PythonTripleQuote = "PythonTripleQuote",
+	/**
+	 * JavaScript/TypeScript JSDoc block comment (opens with two stars, closes
+	 * with star-slash).
+	 */
+	JSDoc = "JSDoc",
+	/** Rust `///` or `//!` doc comment. */
+	Rustdoc = "Rustdoc",
+	/** Go doc comment (a comment block immediately preceding a declaration). */
+	GoDoc = "GoDoc",
+	/**
+	 * Java Javadoc block comment (opens with two stars, closes with
+	 * star-slash).
+	 */
+	JavaDoc = "JavaDoc",
+	/** A language-specific docstring format not covered by the standard variants. */
+	Other = "Other",
+}
+
+/** A docstring extracted from source code. */
+export interface DocstringInfo {
+	/** The raw text of the docstring. */
+	readonly text?: string;
+	/** The docstring format (Python, JSDoc, Rustdoc, etc.). */
+	readonly format?: DocstringFormat;
+	/** Source span covering the docstring. */
+	readonly span?: Span;
+	/** Name of the item this docstring documents. */
+	readonly associatedItem?: string;
+	/** Parsed sections of the docstring (Args, Returns, Raises, etc.). */
+	readonly parsedSections?: Array<DocSection>;
+}
+
+/** Manages downloading and caching of pre-built parser shared libraries. */
+export declare class DownloadManager {
+	/** Create a new download manager for the given version. */
+	static new(version: string): DownloadManager;
+	/** List languages that are already downloaded and cached. */
+	installedLanguages(): Array<string>;
+	/**
+	 * Download the platform bundle and extract every library file it contains.
+	 *
+	 * Unlike [`Self::ensure_languages`], this does not check the manifest language list
+	 * against archive contents — it simply extracts all `.so`/`.dylib`/`.dll` files
+	 * from the bundle. Languages in the manifest that are missing from the archive
+	 * are silently ignored rather than returning an error.
+	 *
+	 * Returns the number of library files extracted (including those already cached).
+	 */
+	downloadAllBestEffort(): number;
+	/**
+	 * Remove all cached parser libraries.
+	 *
+	 * Acquires the cross-process lock so `clean_cache` cannot race a concurrent
+	 * downloader (avoids Windows sharing-violation errors against an in-flight
+	 * bundle write). The `.download.lock` file itself is **not** removed — it is
+	 * permanent infrastructure; deleting it could allow a concurrent process that
+	 * already opened the file to continue holding a stale lock handle while a new
+	 * process opens a fresh inode, breaking the mutual-exclusion guarantee.
+	 */
+	cleanCache(): void;
+}
+
+/** An export statement extracted from source code. */
+export interface ExportInfo {
+	/** The exported name. */
+	readonly name?: string;
+	/** The kind of export (named, default, or re-export). */
+	readonly kind?: ExportKind;
+	/** Source span covering the export statement. */
+	readonly span?: Span;
+}
+
+/**
+ * The kind of an export statement found in source code.
+ *
+ * Covers named exports, default exports, and re-exports from other modules.
+ */
+export declare enum ExportKind {
+	/** A named export (e.g., `export { foo }`). */
+	Named = "Named",
+	/** A default export (e.g., `export default foo`). */
+	Default = "Default",
+	/** A re-export from another module (e.g., `export { foo } from 'bar'`). */
+	ReExport = "ReExport",
+}
+
+/** Aggregate metrics for a source file. */
+export interface FileMetrics {
+	/** Total number of lines (including blank and comment lines). */
+	readonly totalLines?: number;
+	/** Number of lines containing non-blank, non-comment source code. */
+	readonly codeLines?: number;
+	/** Number of lines that are entirely comments. */
+	readonly commentLines?: number;
+	/** Number of blank (whitespace-only) lines. */
+	readonly blankLines?: number;
+	/** Total byte length of the source file. */
+	readonly totalBytes?: number;
+	/** Total number of nodes in the syntax tree. */
+	readonly nodeCount?: number;
+	/** Number of error nodes in the syntax tree (parse errors). */
+	readonly errorCount?: number;
+	/** Maximum nesting depth reached in the syntax tree. */
+	readonly maxDepth?: number;
+}
+
+/** An import statement extracted from source code. */
+export interface ImportInfo {
+	/** The module or path being imported from. */
+	readonly source?: string;
+	/** Specific names imported from the source module. */
+	readonly items?: Array<string>;
+	/** Alias assigned to the import (e.g., `import numpy as np`). */
+	readonly alias?: string;
+	/** Whether this is a wildcard import (e.g., `import *` or `use foo::*`). */
+	readonly isWildcard?: boolean;
+	/** Source span covering the import statement. */
+	readonly span?: Span;
+}
+
+/**
+ * Thread-safe registry of tree-sitter language parsers.
+ *
+ * Manages both statically compiled and dynamically loaded language grammars.
+ * Use [`LanguageRegistry::new()`] for the default registry, or access the
+ * global instance via the module-level convenience functions
+ * (`get_language`, `available_languages`, etc.).
+ */
+export declare class LanguageRegistry {
+	/**
+	 * Create a new registry populated with all statically compiled languages.
+	 *
+	 * When the `dynamic-loading` feature is enabled, the registry also knows
+	 * about dynamically loadable grammars and will load them on demand.
+	 */
+	static new(): LanguageRegistry;
+	/**
+	 * Get a tree-sitter [`Language`] by name.
+	 *
+	 * Resolves aliases (e.g., `"shell"` -> `"bash"`, `"makefile"` -> `"make"`),
+	 * then looks up the language in the static table. When the `dynamic-loading`
+	 * feature is enabled, falls back to loading a shared library on demand.
+	 * @throws Returns [`Error::LanguageNotFound`] if the name (after alias resolution)
+	 * does not match any known grammar.
+	 */
+	getLanguage(name: string): Language;
+	/**
+	 * List all available language names, sorted and deduplicated.
+	 *
+	 * Includes statically compiled languages, dynamically loadable languages
+	 * (if the `dynamic-loading` feature is enabled), and all configured aliases.
+	 */
+	availableLanguages(): Array<string>;
+	/**
+	 * Check whether a parser is statically compiled into this build.
+	 *
+	 * Returns `true` only when the grammar was compiled in at build time
+	 * (i.e. it appears in the `STATIC_LANGUAGES` table). This is independent
+	 * of the extension-to-language mapping: `detect_language_from_extension`
+	 * consults the static ext table for all 306 grammars regardless of which
+	 * parsers are compiled in.
+	 *
+	 * Use this when you need to distinguish "we know the language name" from
+	 * "we can actually parse files in that language right now".
+	 *
+	 * ```no_run
+	 * use tree_sitter_language_pack::{detect_language_from_extension, LanguageRegistry};
+	 *
+	 * let registry = LanguageRegistry::new();
+	 * // Extension detection uses the static table — independent of compiled parsers.
+	 * let lang = detect_language_from_extension("feature"); // always returns Some("gherkin")
+	 * // Parser availability depends on which grammars were compiled in.
+	 * let can_parse = lang.map(|name| registry.has_parser(name)).unwrap_or(false);
+	 * ```
+	 */
+	hasParser(name: string): boolean;
+	/**
+	 * Check whether a language is available by name or alias.
+	 *
+	 * Returns `true` if the language can be loaded, either from the static
+	 * table or from a dynamic library on disk.
+	 */
+	hasLanguage(name: string): boolean;
+	/** Return the total number of available languages (including aliases). */
+	languageCount(): number;
+	/** Parse source code and extract file intelligence based on config in a single pass. */
+	process(source: string, config?: ProcessConfig | undefined | null): ProcessResult;
+	static default(): LanguageRegistry;
+}
+
+/**
+ * A single syntax node within a [`Tree`].
+ *
+ * Nodes hold a strong reference to their parent tree so they remain valid
+ * regardless of how the tree is moved or stored at the FFI boundary.
+ */
+export declare class Node {
+	clone(): Node;
+	/** Return the node's kind name (e.g. `"function_definition"`). */
+	kind(): string;
+	/**
+	 * Return the node's numeric kind ID.
+	 *
+	 * Tree-sitter assigns a stable `u16` ID to every node kind in a grammar
+	 * (e.g. `"function_definition" → 42`). Comparing `kind_id()` is cheaper
+	 * than comparing the string [`kind()`](Self::kind) in tight AST loops.
+	 */
+	kindId(): number;
+	/** Return the inclusive start byte offset of this node. */
+	startByte(): number;
+	/** Return the exclusive end byte offset of this node. */
+	endByte(): number;
+	/**
+	 * Return the node's byte range as a [`ByteRange`].
+	 *
+	 * Callers should slice their own source bytes — this is a zero-copy
+	 * text accessor.
+	 */
+	byteRange(): ByteRange;
+	/** Return the start [`Point`] (row, column). */
+	startPosition(): Point;
+	/** Return the end [`Point`] (row, column). */
+	endPosition(): Point;
+	/** True when this node is named (not punctuation/whitespace). */
+	isNamed(): boolean;
+	/** True when this is an error node. */
+	isError(): boolean;
+	/** True when this is a missing-token node. */
+	isMissing(): boolean;
+	/** True when this is an "extra" node (e.g. a comment). */
+	isExtra(): boolean;
+	/** True when this node or any descendant is an error. */
+	hasError(): boolean;
+	/** Return this node's parent, if any. */
+	parent(): Node | null;
+	/** Return the i-th child of this node, if any. */
+	child(index: number): Node | null;
+	/** Total number of children (including unnamed). */
+	childCount(): number;
+	/** Return the i-th named child of this node, if any. */
+	namedChild(index: number): Node | null;
+	/** Number of named children of this node. */
+	namedChildCount(): number;
+	/** Look up a child by its grammar-defined field name. */
+	childByFieldName(name: string): Node | null;
+	/** Return the S-expression form of this node's subtree. */
+	toSexp(): string;
+	/** Return a [`TreeCursor`] positioned at this node. */
+	walk(): TreeCursor;
+}
+
+/**
+ * Configuration for the tree-sitter language pack.
+ *
+ * Controls cache directory and which languages to pre-download.
+ * Can be loaded from a TOML file, constructed programmatically,
+ * or passed as a dict/object from language bindings.
+ */
+export interface PackConfig {
+	/**
+	 * Override default cache directory.
+	 *
+	 * Default: `~/.cache/tree-sitter-language-pack/v{version}/libs/`
+	 */
+	readonly cacheDir?: string;
+	/**
+	 * Languages to pre-download on init.
+	 *
+	 * Each entry is a language name (e.g. `"python"`, `"rust"`).
+	 */
+	readonly languages?: Array<string>;
+	/** Language groups to pre-download (e.g. `"web"`, `"systems"`, `"scripting"`). */
+	readonly groups?: Array<string>;
+}
+
+/** A tree-sitter parser configured for one language at a time. */
+export declare class Parser {
+	/**
+	 * Construct a new parser with no language set.
+	 *
+	 * Call [`Parser::set_language`] before parsing.
+	 */
+	static new(): Parser;
+	/**
+	 * Configure the parser to use the language identified by name (e.g. `"python"`).
+	 *
+	 * Resolves the language through the global registry — auto-downloading
+	 * if necessary, when the `download` feature is enabled.
+	 * @throws Returns [`Error::LanguageNotFound`] if the language is not recognized,
+	 * or [`Error::ParserSetup`] if the language ABI is incompatible.
+	 */
+	setLanguage(name: string): void;
+	/**
+	 * Parse a UTF-8 source string. Returns `None` if parsing was cancelled
+	 * or no language is set.
+	 */
+	parse(source: string): Tree | null;
+	/**
+	 * Parse a raw byte slice. Returns `None` if parsing was cancelled or
+	 * no language is set.
+	 */
+	parseBytes(source: Uint8Array): Tree | null;
+	/**
+	 * Reset internal state. The next call to [`parse`](Self::parse) will
+	 * not be incremental.
+	 */
+	reset(): void;
+	static default(): Parser;
+}
+
+/** A source position — row + column, zero-indexed. */
+export interface Point {
+	/** Zero-indexed row number. */
+	readonly row: number;
+	/** Zero-indexed column number, in UTF-16 code units. */
+	readonly column: number;
+}
+
+/**
+ * Configuration for the `process()` function.
+ *
+ * Controls which analysis features are enabled and whether chunking is performed.
+ */
+export interface ProcessConfig {
+	/** Language name (required). */
+	readonly language?: string;
+	/** Extract structural items (functions, classes, etc.). Default: true. */
+	readonly structure?: boolean;
+	/** Extract import statements. Default: true. */
+	readonly imports?: boolean;
+	/** Extract export statements. Default: true. */
+	readonly exports?: boolean;
+	/** Extract comments. Default: false. */
+	readonly comments?: boolean;
+	/** Extract docstrings. Default: false. */
+	readonly docstrings?: boolean;
+	/** Extract symbol definitions. Default: false. */
+	readonly symbols?: boolean;
+	/** Include parse diagnostics. Default: false. */
+	readonly diagnostics?: boolean;
+	/** Maximum chunk size in bytes. `None` disables chunking. */
+	readonly chunkMaxSize?: number;
+	/**
+	 * Extract hierarchical key/value data tree from data-format files. Default: false.
+	 *
+	 * When `true`, [`ProcessResult::data`](crate::ProcessResult::data) is populated
+	 * with a [`DataNode`](crate::DataNode) tree for supported languages: JSON, YAML,
+	 * TOML, `.properties`, HCL/HOCON, INI, editorconfig, KDL, CUE, CSV, PSV, PO,
+	 * nginx config, Caddy config, XML, and DTD.
+	 *
+	 * For languages outside this set the field is left as `None`.
+	 */
+	readonly dataExtraction?: boolean;
+}
+
+/**
+ * Complete analysis result from processing a source file.
+ *
+ * Contains metrics, structural analysis, imports/exports, comments,
+ * docstrings, symbols, diagnostics, and optionally chunked code segments.
+ * Fields are populated based on the `ProcessConfig` flags.
+ *
+ * # Fields
+ *
+ * - `language` - The language used for parsing
+ * - `metrics` - Always computed: line counts, byte sizes, error counts
+ * - `structure` - Functions, classes, structs (when `config.structure = true`)
+ * - `imports` - Import statements (when `config.imports = true`)
+ * - `exports` - Export statements (when `config.exports = true`)
+ * - `comments` - Comments (when `config.comments = true`)
+ * - `docstrings` - Docstrings (when `config.docstrings = true`)
+ * - `symbols` - Symbol definitions (when `config.symbols = true`)
+ * - `diagnostics` - Parse errors (when `config.diagnostics = true`)
+ * - `chunks` - Chunked code segments (when `config.chunk_max_size` is set)
+ */
+export interface ProcessResult {
+	/** The language name used to parse the source file. */
+	readonly language?: string;
+	/** File-level metrics (line counts, byte size, error count). */
+	readonly metrics?: FileMetrics;
+	/** Top-level structural items (functions, classes, etc.). */
+	readonly structure?: Array<StructureItem>;
+	/** Import statements extracted from the source. */
+	readonly imports?: Array<ImportInfo>;
+	/** Export statements extracted from the source. */
+	readonly exports?: Array<ExportInfo>;
+	/** Comments extracted from the source. */
+	readonly comments?: Array<CommentInfo>;
+	/** Docstrings extracted from the source. */
+	readonly docstrings?: Array<DocstringInfo>;
+	/** Symbol definitions (variables, types, functions) extracted from the source. */
+	readonly symbols?: Array<SymbolInfo>;
+	/** Parse diagnostics (syntax errors, missing nodes) from tree-sitter. */
+	readonly diagnostics?: Array<Diagnostic>;
+	/** Syntax-aware code chunks produced when chunking is enabled. */
+	readonly chunks?: Array<CodeChunk>;
+	/**
+	 * Hierarchical data tree extracted when `config.data_extraction` is `true`.
+	 *
+	 * Populated for supported data-format languages (JSON, YAML, TOML, properties,
+	 * HCL, INI, XML, CSV, and more). `None` when `data_extraction` is `false` (the
+	 * default) or when the language is not a recognised data format.
+	 *
+	 * See [`DataNode`] for the shape of the returned tree.
+	 */
+	readonly data?: DataNode;
+}
+
+/**
+ * Byte and line/column range in source code.
+ *
+ * Represents both byte offsets (for slicing) and human-readable line/column
+ * positions (for display and diagnostics).
+ */
+export interface Span {
+	/** Inclusive start byte offset in the source. */
+	readonly startByte?: number;
+	/** Exclusive end byte offset in the source. */
+	readonly endByte?: number;
+	/** Zero-indexed line number of the span's start. */
+	readonly startLine?: number;
+	/** Zero-indexed column number of the span's start. */
+	readonly startColumn?: number;
+	/** Zero-indexed line number of the span's end. */
+	readonly endLine?: number;
+	/** Zero-indexed column number of the span's end. */
+	readonly endColumn?: number;
+}
+
+/** A structural item (function, class, struct, etc.) in source code. */
+export interface StructureItem {
+	/** The kind of structural item. */
+	readonly kind?: StructureKind;
+	/** The declared name of the item, if present. */
+	readonly name?: string;
+	/** Visibility modifier (e.g., `"pub"`, `"public"`, `"private"`). */
+	readonly visibility?: string;
+	/** Source span covering the entire item declaration. */
+	readonly span?: Span;
+	/** Nested structural items (e.g., methods within a class). */
+	readonly children?: Array<StructureItem>;
+	/** Decorator or attribute names applied to the item. */
+	readonly decorators?: Array<string>;
+	/** Documentation comment attached to the item, if any. */
+	readonly docComment?: string;
+	/** Full signature text of the item (e.g., function parameters and return type). */
+	readonly signature?: string;
+	/** Source span covering only the body of the item, if distinct from the declaration. */
+	readonly bodySpan?: Span;
+}
+
+/**
+ * The kind of structural item found in source code.
+ *
+ * Categorizes top-level and nested declarations such as functions, classes,
+ * structs, enums, traits, and more. Use [`Other`](StructureKind::Other) for
+ * language-specific constructs that do not fit a standard category.
+ *
+ * # Wire format (public JSON contract)
+ *
+ * Unit variants serialize as a bare string (`"Function"`); the `Other`
+ * variant serializes as a single-keyed object (`{"Other": "macro"}`). DO
+ * NOT add `#[serde(tag = "...")]` or rename variants — every language
+ * binding has a hand-written deserializer matching this exact shape, and
+ * any change breaks all bindings' `process()` tests simultaneously.
+ * Covered by `tests/wire_format.rs`.
+ */
+export declare enum StructureKind {
+	/** A free-standing or associated function. */
+	Function = "Function",
+	/** A method defined inside a class, struct, trait, or impl block. */
+	Method = "Method",
+	/** A class definition. */
+	Class = "Class",
+	/** A struct definition. */
+	Struct = "Struct",
+	/** An interface or protocol definition. */
+	Interface = "Interface",
+	/** An enum definition. */
+	Enum = "Enum",
+	/** A module or package declaration. */
+	Module = "Module",
+	/** A trait definition. */
+	Trait = "Trait",
+	/** An impl block (Rust) or similar implementation block. */
+	Impl = "Impl",
+	/** A namespace declaration. */
+	Namespace = "Namespace",
+	/** A language-specific construct that does not fit any standard category. */
+	Other = "Other",
+}
+
+/** A symbol (variable, function, type, etc.) extracted from source code. */
+export interface SymbolInfo {
+	/** The name of the symbol. */
+	readonly name?: string;
+	/** The kind of symbol (variable, function, class, etc.). */
+	readonly kind?: SymbolKind;
+	/** Source span covering the symbol definition. */
+	readonly span?: Span;
+	/** Explicit type annotation, if present in the source. */
+	readonly typeAnnotation?: string;
+	/** Documentation comment associated with this symbol. */
+	readonly doc?: string;
+}
+
+/**
+ * The kind of a symbol definition found in source code.
+ *
+ * Categorizes symbol definitions such as variables, constants, functions,
+ * classes, types, interfaces, enums, and modules.
+ *
+ * # Wire format (public JSON contract)
+ *
+ * Unit variants serialize as a bare string (`"Function"`); the `Other`
+ * variant serializes as a single-keyed object (`{"Other": "macro"}`). DO
+ * NOT add `#[serde(tag = "...")]`. Covered by `tests/wire_format.rs`.
+ */
+export declare enum SymbolKind {
+	/** A variable binding. */
+	Variable = "Variable",
+	/** A constant (immutable binding). */
+	Constant = "Constant",
+	/** A function definition. */
+	Function = "Function",
+	/** A class definition. */
+	Class = "Class",
+	/** A type alias or typedef. */
+	Type = "Type",
+	/** An interface definition. */
+	Interface = "Interface",
+	/** An enum definition. */
+	Enum = "Enum",
+	/** A module declaration. */
+	Module = "Module",
+	/** A symbol kind not covered by the standard variants. */
+	Other = "Other",
+}
+
+/** A parsed syntax tree. Cheap to clone (refcount bump). */
+export declare class Tree {
+	/** Return the root [`Node`] of this tree. */
+	rootNode(): Node;
+	/** Return a [`TreeCursor`] positioned at the root. */
+	walk(): TreeCursor;
+}
+
+/** A cursor for traversing a [`Tree`]. */
+export declare class TreeCursor {
+	/** Return the [`Node`] at the cursor's current position. */
+	node(): Node;
+	/**
+	 * Move the cursor to the first child of the current node.
+	 * Returns `true` if a child existed.
+	 */
+	gotoFirstChild(): boolean;
+	/**
+	 * Move the cursor to the parent of the current node.
+	 * Returns `true` if a parent existed.
+	 */
+	gotoParent(): boolean;
+	/**
+	 * Move the cursor to the next sibling of the current node.
+	 * Returns `true` if a sibling existed.
+	 */
+	gotoNextSibling(): boolean;
+	/** Return the field name for the current node, if any. */
+	fieldName(): string | null;
+}
+
+/**
+ * Return the number of available languages.
+ *
+ * Includes statically compiled languages, dynamically loadable languages,
+ * and aliases.
+ */
+export declare function languageCount(): number;
+
+/**
+ * Return all language names available in the remote manifest (306).
+ *
+ * Fetches (and caches) the remote manifest to discover the full list of
+ * downloadable languages. Use [`downloaded_languages`] to list what is
+ * already cached locally.
+ * @throws Returns an error if the manifest cannot be fetched.
+ */
+export declare function manifestLanguages(): Array<string>;
+
+/**
+ * Process source code and extract file intelligence using the global registry.
+ *
+ * Parses the source with tree-sitter and extracts metrics, structure, imports,
+ * exports, comments, docstrings, symbols, diagnostics, and/or chunks based on
+ * the flags set in [`ProcessConfig`].
+ * @throws Returns an error if the language is not found or parsing fails.
+ */
+export declare function process(source: string, config?: ProcessConfig | undefined | null): ProcessResult;

package/index.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const { platform, arch } = process;
+const isWindows = platform === "win32";
+const isMusl = () => {
+  // Prefer the report-header `glibcVersion` string when present — fastest and
+  // unambiguous on Node builds that populate it. On Node 22+, certain CI
+  // environments leave `glibcVersion` undefined even on glibc systems, so the
+  // `=== undefined` branch from older napi-rs templates produces a false
+  // "is musl" positive. Fall through to the filesystem heuristic instead: on
+  // glibc systems `/lib64/ld-musl-x86_64.so.1` does not exist; on musl systems
+  // it always does. statSync errors → not musl.
+  if (
+    typeof process.report === "object" &&
+    typeof process.report.getReport === "function"
+  ) {
+    const report = process.report.getReport();
+    if (
+      report &&
+      report.header &&
+      typeof report.header.glibcVersion === "string"
+    ) {
+      return false;
+    }
+  }
+  try {
+    require("fs").statSync("/lib64/ld-musl-x86_64.so.1");
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+let nativeBinding = null;
+const loadErrors = [];
+
+function requireOptionalDependency(name) {
+  try {
+    return require(name);
+  } catch (e) {
+    loadErrors.push(`Optional dependency ${name}: ${e.message}`);
+    return null;
+  }
+}
+
+const tryLoadBinding = () => {
+  // Local `.node` files are named after `napi.binaryName` (binary file name on disk).
+  // Optional-dep packages are named after `napi.packageName` (npm subpackage names),
+  // which inherits any scope prefix from the parent package.
+  const targets = [
+    ["linux", "x64", "gnu", "./ts-pack-core-node.linux-x64-gnu.node", "@xberg-io/tree-sitter-language-pack-linux-x64-gnu"],
+    ["linux", "arm64", "gnu", "./ts-pack-core-node.linux-arm64-gnu.node", "@xberg-io/tree-sitter-language-pack-linux-arm64-gnu"],
+    ["linux", "x64", "musl", "./ts-pack-core-node.linux-x64-musl.node", "@xberg-io/tree-sitter-language-pack-linux-x64-musl"],
+    ["linux", "arm64", "musl", "./ts-pack-core-node.linux-arm64-musl.node", "@xberg-io/tree-sitter-language-pack-linux-arm64-musl"],
+    ["darwin", "x64", null, "./ts-pack-core-node.darwin-x64.node", "@xberg-io/tree-sitter-language-pack-darwin-x64"],
+    ["darwin", "arm64", null, "./ts-pack-core-node.darwin-arm64.node", "@xberg-io/tree-sitter-language-pack-darwin-arm64"],
+    ["win32", "x64", null, "./ts-pack-core-node.win32-x64-msvc.node", "@xberg-io/tree-sitter-language-pack-win32-x64-msvc"],
+    ["win32", "arm64", null, "./ts-pack-core-node.win32-arm64-msvc.node", "@xberg-io/tree-sitter-language-pack-win32-arm64-msvc"],
+  ];
+
+  for (const [plat, a, abi, localPath, optionalDep] of targets) {
+    if (platform !== plat || arch !== a) {
+      continue;
+    }
+
+    if (plat === "linux" && abi) {
+      const isCurMusl = isMusl();
+      if ((abi === "musl") !== isCurMusl) {
+        continue;
+      }
+    }
+
+    try {
+      nativeBinding = require(localPath);
+      if (nativeBinding) {
+        return;
+      }
+    } catch (e) {
+      loadErrors.push(e.message);
+    }
+
+    try {
+      const optBinding = requireOptionalDependency(optionalDep);
+      if (optBinding) {
+        nativeBinding = optBinding;
+        return;
+      }
+    } catch (e) {
+      loadErrors.push(e.message);
+    }
+  }
+};
+
+tryLoadBinding();
+
+if (!nativeBinding) {
+  throw new Error(
+    `Failed to load native binding for ${platform}-${arch}. Errors: ${loadErrors.join(", ")}`
+  );
+}
+
+module.exports = nativeBinding;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@xberg-io/tree-sitter-language-pack",
+  "version": "0.0.1",
+  "description": "Pre-compiled tree-sitter grammars for 306 programming languages",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xberg-io/tree-sitter-language-pack.git"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "*.node"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "@xberg-io/tree-sitter-language-pack-darwin-arm64": "0.0.1",
+    "@xberg-io/tree-sitter-language-pack-darwin-x64": "0.0.1",
+    "@xberg-io/tree-sitter-language-pack-linux-arm64-gnu": "0.0.1",
+    "@xberg-io/tree-sitter-language-pack-linux-arm64-musl": "0.0.1",
+    "@xberg-io/tree-sitter-language-pack-linux-x64-gnu": "0.0.1",
+    "@xberg-io/tree-sitter-language-pack-linux-x64-musl": "0.0.1",
+    "@xberg-io/tree-sitter-language-pack-win32-arm64-msvc": "0.0.1",
+    "@xberg-io/tree-sitter-language-pack-win32-x64-msvc": "0.0.1"
+  },
+  "napi": {
+    "binaryName": "ts-pack-core-node",
+    "packageName": "@xberg-io/tree-sitter-language-pack",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "aarch64-unknown-linux-musl",
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-pc-windows-msvc",
+      "aarch64-pc-windows-msvc"
+    ]
+  },
+  "engines": {
+    "node": ">= 18"
+  }
+}