Returns the cached next occurrence of ch at or after from, re-probing with indexOf only when the cached position has fallen behind. Infinity when the text has no further occurrence — a monotonic probe that keeps delimiter scans linear across a construct that is dense in ch.

Wires up CSS Custom Highlight API range highlighting for a single element's text node, shared by CodeHighlight and CodeTextarea. Creates a HighlightManager, memoizes tokenization, applies/clears ranges in an effect, emits DEV warnings for unsupported languages, and tears down on destroy.

Must be called during component initialization (it uses $effect/onDestroy).

Manages CSS Custom Highlight API ranges for a single element's text node. Tracks ranges per element and only removes its own ranges when clearing, cooperating with other managers that share the global CSS.highlights registry.

Experimental — limited browser support. Use Code.svelte for production block code; this powers the experimental CodeHighlight and CodeTextarea.

A \w word char — ASCII letters, digits, and _.

Lexes one <… construct at i, returning the next scan position. Exported for lexer_md, which dispatches raw markup out of markdown text.

The shared markup window lexer — lexes [l.pos, l.end) per mode. The entry point for the html/xml registrations here and for lexer_svelte.

Lexes text with lang, returning the flat token event stream.

The result of lexing: the source text plus its flat token event stream.

Shared lexing context passed to language lex functions. Holds the text window, the event buffer, and the language registry for embedding.

The shell (bash-family) language registration for the lexer engine.

Registered as sh; bash and shell alias it: POSIX sh is a syntactic subset of bash for highlighting purposes, and the bash-only constructs this lexer additionally recognizes don't occur in sh input, so running it on sh scripts is exact. There is no separate sh lexer.

The CSS language registration for the lexer engine.

The JSON language registration for the lexer engine.

The HTML markup language registration for the lexer engine.

The Markdown language registration for the lexer engine.

The Svelte language registration for the lexer engine.

The TypeScript language registration for the lexer engine.

JavaScript reuses this lexer via the js/javascript aliases: TypeScript is a syntactic superset, and the TS-only constructs the lexer recognizes (type annotations, as, generics before a call) can't appear in valid JS, so running the full TS lexer on JS is a no-op for those paths. There is no separate JS lexer.

The XML language registration — the same scanner without HTML's rawtext elements or style=/on*= attribute embedding.

The html dialect mode — also used by lexer_md for raw markup embedded in markdown text.

Dialect configuration for the shared markup scanner — how html, xml, and svelte differ. Instances are module-level constants (one per dialect) so the scanner stays monomorphic.

Monotonic next-occurrence caches for the markup scanner's probes (see advance_probe). The scan visits constructs in increasing position order, but its probes (</{ between constructs, & in text gaps and attribute values) target chars the current construct doesn't consume — without the caches, input dense in one probe char but lacking another re-scans the document tail per construct, quadratic in document size. One cache spans a whole window scan (or a whole md document scan, threaded through lex_markup_construct); embedded guest windows create their own.

Case-insensitive ASCII match of word (must be lowercase) at text[from..], via code | 0x20 folding — never allocates, unlike toLowerCase() comparisons.

Options for svelte_preprocess_fuz_code.

Reactive outputs from create_range_highlighting.

Reactive inputs for create_range_highlighting. All values are getters so the helper can track the consuming component's reactive state across the call boundary (the Svelte 5 getter-injection pattern).

Renders a lexed token event stream to HTML in one forward pass. Gap text is copy-escaped; token spans use the precomputed open tags.

Finds the matching } for the { at i, skipping js-style strings, templates, and comments. Returns -1 when unbalanced within the window.

Scans an entity reference at the & at i, returning its exclusive end or -1. Accepts a named form (1–8 case-insensitive alphanumerics, &…;) and a numeric form (&#…; or &#x…;, 1–8 hex digits allowed in both).

Scans an identifier starting at from (assumed to be an identifier start), returning the exclusive end index.

Returns the index of the next \n at or after i (exclusive end of the line's content, excluding a preceding \r), or end when there is none. Uses native indexOf — the fast path for line-oriented scans.

Skips a js-style quoted span from the quote at from (used inside balanced scans), returning the index after the closing quote. Unterminated '/" strings stop at the newline; templates (`` `) span lines.

Skips whitespace (including newlines) from from, returning the next non-space index.

Checks for CSS Highlights API support.

Svelte preprocessor that compiles static Code component content at build time, replacing runtime syntax highlighting with pre-rendered HTML.

Flattens a lexed event stream to SyntaxEventTokens in document order (containers precede their children).

Pre-configured SyntaxStyler instance with all built-in languages registered.

A flattened token span, in document order with containers before their children. Used by fixtures, tests, and range building.

A lexer-based language registration.

Registry and facade over the hand-written lexer engine (lexer.ts): registers languages, lexes text to a flat token event stream, and renders that stream to syntax-highlighted HTML.

Interns a token type into token_types_global — the zero-config authoring path used by the built-in lexers' module-load type constants.

The shared default registry — the single id space used by the built-in lexers' module-load token_type constants and by any SyntaxStyler not given its own registry. The type vocabulary is global by design, mirroring the global .token_* CSS namespace; per-registry isolation exists for fully-custom stylers and tests, whose lexers must intern into the same registry they're rendered against.

Interned metadata for a token type.

An id space of interned token types with precomputed CSS classes and HTML open tags. Ids are only meaningful against the registry that interned them — a lexed event stream resolves back through the registry stamped on its LexedSyntax.

Trims trailing whitespace from a [from, to) span, returning the new exclusive end.

Validates a lexed event stream's structural invariants, returning a list of human-readable issues (empty when valid): records well-formed, offsets monotonic and in-bounds, containers balanced.

Builds a word→kind classification map from [kind, words] entries, where words is space-separated — the shared shape of the lexers' keyword tables.