@lanexio/parser

This page documents @lanexio/parser, the main entry point package that provides a unified API across all Lanexio Parser grammars: parse, createParser, register, and detectLanguage.

• Version: Stable
• Module name: parser
• Package: @lanexio/parser
• Import path: @lanexio/parser
• Layer: 6 (Entry)
• Runtime: Universal
• Module format: ESM
• Stability: Stable
• Primary use case: Unified parsing API across all grammar packs.

Layer contract

Layer 6 dependency rules

@lanexio/parser is a universal re-export entry point. It depends on Layers 1-2 and re-exports core APIs along with the unified parse function.

When to use this module

• You want a single parse() function that auto-detects the grammar.
• You want to register multiple grammars and switch between them by language, file extension, or MIME type.
• You want a single import instead of importing each grammar pack individually.

Module boundary

Boundary	Description
Inputs	Uint8Array (source bytes) + ParseOptions (language, grammar)
Outputs	LexTree
Side effects	register() mutates grammarRegistry. grammarRegistry is a shared global.
Determinism	Yes (same input + same registrations produce same tree)
External dependencies	@lanexio/parser-core, @lanexio/parser-wasm (optional)
Never-throw guarantee	No: parse() throws LanexioParseError when auto-detection fails and no grammar is specified. Grammar-specific parse functions within a created parser are never-throw.
Security surface	None

Installation

1. Install the package.

   pnpm

   pnpm add @lanexio/parser

   npm

   npm install @lanexio/parser

   yarn

   yarn add @lanexio/parser

2. Import the named export.

   import { parse, createParser, register } from '@lanexio/parser';

Peer dependencies

Requirement	Required	Layer	Notes
@lanexio/parser-core	Yes	1	^1.0.0
@lanexio/parser-wasm	No	4	Optional WASM bridge
Grammar packages	No	2	Must be registered before use

Basic Usage

import { parse, register } from '@lanexio/parser';
import { htmlRegistration } from '@lanexio/parser-grammar-html';

register(htmlRegistration);

const encoder = new TextEncoder();
const tree = parse(encoder.encode('<p>Hello</p>'), { language: 'html' });

console.log(tree.nodeCount);

Auto-detection

// Detects grammar from file extension hints in ParseOptions
const tree = parse(encoder.encode('<p>Hello</p>'), { grammar: htmlGrammar });

Create a parser handle

import { createParser } from '@lanexio/parser';
import { htmlGrammar } from '@lanexio/parser-grammar-html';

const parser = createParser(htmlGrammar);
const tree = parser.parse(encoder.encode('<p>Hello</p>'));

Exports

Export	Type	Description
parse	(source: Uint8Array, options?: ParseOptions) => LexTree	Unified parse entry point. Throws LanexioParseError on detection failure.
createParser	(grammar: LanexioParserPureGrammar) => LanexioParser	Create a parser handle bound to a specific grammar.
register	(registration: GrammarRegistration) => void	Register a grammar in the unified registry.
detectLanguage	(source: Uint8Array, hints?: DetectionHints) => DetectionResult	Auto-detect the grammar language from source bytes.
actionableError	(error: LanexioParseError) => string	Generate a human-readable error message.
KNOWN_GRAMMARS	readonly KnownGrammarEntry[]	List of pre-registered known grammars.
LanexioParserError	class	Parser error base class.
LanexioParserErrorCode	const object	Error code constants.
LanexioParseError	class	Error thrown when parsing fails (e.g., unknown grammar).
grammarRegistry	object	Global grammar registry (re-exported from parser-core).
LexCursor	class	Re-export from parser-core.
LexNode	class	Re-export from parser-core.
LexToyKind	const object	Re-export from parser-core.
LexTree	class	Re-export from parser-core.
PROTOCOL_VERSION	number	Re-export from parser-core.
LexEditError	class	Re-export from parser-core.
LexEditErrorCode	const object	Re-export from parser-core.
applyEdit	function	Re-export from parser-core.
toyParse	function	Re-export from parser-core (toy grammar parse).
createParseStream	function	Re-export from parser-core.

Options

ParseOptions

Field	Type	Required	Default	Description
language	string	No	undefined	Language name for grammar lookup (e.g., "html", "markdown").
grammar	LanexioParserPureGrammar	No	undefined	Explicit grammar descriptor (skips registry lookup).

Return shape

Property	Type	Description
root	LexNode	Root node of the parsed tree.
nodeCount	number	Total nodes in the tree.
source	Uint8Array	Original parsed bytes.

Exported types

Type	Purpose	Notes
ParseOptions	Options for parse()	{ language?: string; grammar?: LanexioParserPureGrammar }
LanexioParser	Parser handle returned by createParser	{ parse: (bytes: Uint8Array) => LexTree }
DetectionResult	Result of language detection	Language and confidence
DetectionHints	Hints for language detection	Extension, MIME type
KnownGrammarEntry	Entry in KNOWN_GRAMMARS	Grammar metadata
LexRange	Byte range	Re-export from parser-core
LanexioParserPureGrammar	Grammar descriptor	Re-export from parser-core
LexParseStream	Streaming parse interface	Re-export from parser-core
GrammarRegistration	Grammar registration	Re-export from parser-core
LexEdit	Edit descriptor	Re-export from parser-core

Configuration and Extension

Grammar registration

Register grammars before calling parse(). The registry supports lookup by language name, file extension, and MIME type.

Known grammars

KNOWN_GRAMMARS lists the pre-registered grammar metadata. This is a read-only list for reference.

Accessibility

Accessibility requirements

• No direct accessibility surface. The main entry point dispatches to grammar-specific parsers. Consuming code is responsible for semantic rendering.

Accessibility checklist

Concern	Status
Generated output semantics	Not applicable (dispatch layer)
ARIA attributes in serialized output	Not applicable
Semantic element round-trip	Not applicable

Security

Security considerations

• The unified parse() function relies on auto-detection. Grammar-specific parse functions within created parsers are never-throw.
• When auto-detection fails and no grammar is specified, parse() throws LanexioParseError.

Threat	Mitigation	Status
Malformed input byte sequence	Delegated to grammar-specific parsers (all grammar parsers are never-throw)	Implemented
Grammar detection failure	Throws LanexioParseError with clear message	Implemented

Companion packages

Package	Relationship	Layer	Notes
@lanexio/parser-core	Requires	1	Core tree and protocol. Re-exported.
@lanexio/parser-grammar-html	Dev dependency	2	Optional grammar.
@lanexio/parser-grammar-markdown	Dev dependency	2	Optional grammar.
@lanexio/parser-wasm	Requires	4	WASM bridge support.

Changelog

Version	Date	Status	Notable changes
1.0.0	2026-05-29	Current	Initial stable release. Apache-2.0.

Migration notes

• None.

Related Content

Installation Install Lanexio Parser packages.

Quick Start Parse HTML and Markdown in five lines each.

Flat AST How the 16-byte node layout works.

Stability Guarantees Never-throw, panic-free, and 3-token recovery.