import { type Lexer, type SyntaxLang } from './lexer.js';
/**
 * 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.
 */
export interface MarkupLexMode {
    /**
     * Language embedded in `<script>` rawtext regions (resolved through the
     * lexer registry at lex time), or null to disable rawtext regions
     * entirely (xml).
     */
    script_embed: string | null;
    /**
     * Container type id wrapping script content — `lang_js` for html,
     * `lang_ts` for svelte. Unused when `script_embed` is null.
     */
    script_container: number;
    /**
     * RCDATA `textarea`/`title` regions (html only — svelte keeps
     * expressions live inside them).
     */
    rcdata: boolean;
    /**
     * `style=`/`on*=` attribute embedding (html only).
     */
    special_attrs: boolean;
    /**
     * 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).
     */
    attr_comments: boolean;
    /**
     * 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.
     */
    lex_expression: ((l: Lexer, from: number, end: number, full: boolean) => number) | null;
}
/**
 * The html dialect mode — also used by `lexer_md` for raw markup embedded in
 * markdown text.
 */
export declare const MARKUP_MODE_HTML: MarkupLexMode;
/**
 * 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.
 */
export interface MarkupProbeCache {
    lt: number;
    brace: number;
    amp: number;
}
export declare const create_markup_probe_cache: () => MarkupProbeCache;
/**
 * 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).
 */
export declare const scan_entity_end: (text: string, i: number, end: number) => number;
/**
 * Lexes one `<…` construct at `i`, returning the next scan position.
 * Exported for `lexer_md`, which dispatches raw markup out of markdown text.
 */
export declare const lex_markup_construct: (l: Lexer, i: number, end: number, mode: MarkupLexMode, cache: MarkupProbeCache) => number;
/**
 * 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`.
 */
export declare const lex_markup_window: (l: Lexer, mode: MarkupLexMode) => void;
/**
 * The HTML markup language registration for the lexer engine.
 */
export declare const lexer_markup: SyntaxLang;
/**
 * The XML language registration — the same scanner without HTML's rawtext
 * elements or `style=`/`on*=` attribute embedding.
 */
export declare const lexer_xml: SyntaxLang;
//# sourceMappingURL=lexer_markup.d.ts.map