api #

The source code to style.

Language identifier (e.g. 'ts', 'css', 'html', 'json', 'svelte', 'md'). Selects the registered lexer and sets the data-lang attribute. null or an unregistered id disables styling (content renders as plain text, and an unregistered id logs an error in DEV); undefined falls back to the default ('svelte').

Whether to render as inline code instead of a block.

Whether to wrap long lines in block code (white-space: pre-wrap instead of pre). Wraps at whitespace — long unbroken tokens (URLs, hashes) still scroll horizontally. Ignored for inline code.

Whether to disable the default margin-bottom on block code (var(--space_lg) when not :last-child).

Custom SyntaxStyler instance, e.g. with different languages registered.

Optional snippet to customize how the styled markup is rendered. Receives the generated HTML string as a parameter.

The source code to syntax highlight.

Language identifier (e.g. 'ts', 'css', 'html', 'json', 'svelte', 'md'). Selects the registered lexer and sets the data-lang attribute. null or an unregistered id disables highlighting (content renders as plain text, and an unregistered id logs an error in DEV); undefined falls back to the default ('svelte').

Highlighting mode: 'auto' uses the CSS Custom Highlight API when supported and falls back to HTML, 'ranges' forces the Highlight API (requires browser support), 'html' forces HTML generation with CSS classes. The Highlight API has limited browser support and requires theme_highlight.css instead of theme.css.

Whether to render as inline code instead of a block.

Whether to wrap long lines in block code (white-space: pre-wrap instead of pre). Wraps at whitespace — long unbroken tokens (URLs, hashes) still scroll horizontally. Ignored for inline code.

Custom SyntaxStyler instance, e.g. with different languages registered.

Optional snippet to customize how the highlighted markup is rendered.

• In HTML mode: receives the generated HTML string
• In range mode: receives the plain text content

The editable source code. Bindable.

Language identifier (e.g. 'ts', 'css', 'svelte'). null disables styling; undefined falls back to the default ('svelte').

Custom SyntaxStyler instance (defaults to the global one).

Attributes for the wrapper <div> — the layout box that the textarea fills and resize grows. Use it for sizing/layout classes, style, id, or container-level handlers. Its class is merged with the internal code_textarea class; data-lang stays component-controlled. (...rest spreads onto the <textarea>; the backdrop <pre> is internal and intentionally not exposed.)

This manager's ranges, keyed by prefixed highlight name (e.g. token_keyword). A single range object may be shared across several names (a token type plus its aliases), since one range can belong to multiple Highlight sets.

Highlights element's text node from a lexed event stream. Ranges come straight from event offsets — no position reconstruction. Clears this manager's previous ranges first.

A missing text node is a no-op. Offsets past the text node's length are clamped (a DOM/source mismatch is the caller's concern, not a throw here).

Clears only this manager's ranges from the shared highlights. Defensive: a highlight may already be gone (e.g. another manager removed the last range, or HMR reset the registry), which is a valid state, not an error.

registry used to resolve embedded languages by id

token-type registry stamped on the result; must be the one lang (and any embedded language) interned its type ids into

The registry that interned the type ids in events — consumers resolve ids through it, so a stream can never be rendered against the wrong id space.

Language registry for embed — set by lex_syntax.

One instance alive for the class's lifetime. V8 holds the hidden class of an initialized Lexer only through live instances, and lex_syntax makes one per call, so without it a major GC between calls clears the class and discards every optimized lexer function that embeds it. Every field is declared here, so this instance's hidden class is the one every lexer has. A static rather than a module variable: V8 frees a module variable that no function reads once the module has evaluated, and bundlers drop an unused export.

Emits a leaf token. Empty spans are dropped; a leaf adjacent to a preceding leaf of the same type extends it instead (span coalescing).

Opens a container token at start. Must be balanced by a later close.

Closes the innermost open container at end.

Lexes [start, end) with the language registered as lang_id, restoring this lexer's window afterward. Returns false (leaving the region as plain text) when the language isn't registered or embedding is nested past MAX_EMBED_DEPTH.

Lexes an embedded region that starts at start and ends at its closing }, somewhere before end, with the language registered under lang_id, which finds the brace through SyntaxLang.lex_to_brace. Returns the brace's index, or -1 when the region ran to end without one, or EMBED_UNAVAILABLE when nothing was lexed: the language is unregistered or has no lex_to_brace, or nesting is at MAX_EMBED_DEPTH. With a stop_word the region also ends before that word at its top level, and the word's index is returned.

Language embedded in <script> rawtext regions (resolved through the lexer registry at lex time), or null to disable rawtext regions entirely (xml).

Container type id wrapping script content — lang_js for html, lang_ts for svelte. Unused when script_embed is null.

RCDATA textarea/title regions (html only — svelte keeps expressions live inside them).

style=/on*= attribute embedding (html only).

JS-style line and block comments between attributes emit comment leaves (svelte only — in html/xml a // inside a tag is ordinary bogus attribute text, not a comment).

Lexes a {…} expression at from, returning the position after it — the svelte hook, null for html/xml. full enables block/each forms (top level); tag and attribute contexts get the simple form.

File patterns to exclude.

Custom SyntaxStyler instance.

Enable in-memory caching.

Import sources that resolve to the Code component. Used to verify that <Code> in templates actually refers to Code.svelte.

How to handle errors.

The element whose first text node receives the highlight ranges.

The text to tokenize. Must match the element's text node exactly (e.g. a textarea backdrop includes its trailing newline here too).

Language id; null disables highlighting.

The syntax styler whose registered languages back lang lookups.

Extra gate — ranges are only applied when this returns true. Defaults to always-on.

Component name used in DEV warnings.

PreprocessFuzCodeOptions configuration

Primary language id, e.g. 'ts'.

Alternate ids resolving to this language, e.g. ['typescript'].

Lexes the lexer's current [pos, end) window, emitting token events. Must never throw and must always terminate with lexer.pos === lexer.end.

Lexes from lexer.pos as lex does, but stops at the first } that closes no { of the region's own, for a host whose region ends at that brace (a Svelte {expression}). Returns the brace's index, leaving lexer.pos there, or -1 after lexing to lexer.end without meeting one. The lexer finds the brace as it tokenizes, so a brace in a string, comment, or regex doesn't count. Optional: a host falls back to finding the brace itself.

With a stop_word, it also stops before that word where it stands alone outside every bracket of the region (the as of a Svelte {#each}), and returns the word's index instead; the host tells the two apart by the char there.

Registered languages, keyed by id and by each alias.

Token-type id space for this styler's languages. See SyntaxStylerOptions.token_types.

Registers a language (and its aliases).

Whether a language is registered under id (its primary id or an alias).

Lexes text with the language registered as lang, returning the flat event stream, valid until the next lex (see lex_syntax). Throws when lang is not registered — see has_lang.

Generates syntax-styled HTML (spans with .token_* classes) from text. Throws when lang is not registered — see has_lang.

Token-type id space used by the registered lexers. Defaults to the shared token_types_global, which the built-in lexers intern into — inject a separate registry only when every registered lexer interns into that same registry.

Space-separated CSS classes, e.g. 'token_null token_keyword'.

Precomputed HTML open tag, e.g. '<span class="token_null token_keyword">'.

The whole rendered span of each one-char ASCII leaf of this type, indexed by char code, '' where not yet rendered. render_syntax_html fills it as it meets them; null until the first.

Interned infos indexed by id. Hot loops hoist and index this directly; grow it only via intern.

Interns a token type by name (+ optional aliases) and returns its id. Repeated calls with the same name and aliases return the same id. The CSS class list and HTML open tag are precomputed here so emitters never build class strings at runtime.

Looks up the interned info for a token type id.

Returns the value of the word text[start, end) spells, or 0 when it is none of the table's.