/**
 * An allowlist HTML sanitiser for richtext field values.
 *
 * **Why this exists.** Richtext is stored as HTML and rendered with Astro's `set:html`, which does
 * not escape. Without sanitising on the way in, anyone who can edit content — a contributor, the
 * lowest role there is — could store `<script>` or `<img onerror>` and have it run for every
 * visitor and for every editor who opens the item. That is stored XSS, and the session it steals
 * is an administrator's.
 *
 * **Why on the server, on write.** The editor is not a security boundary: the REST API accepts a
 * richtext value from any client holding a session, so a `curl` request bypasses whatever the
 * toolbar permits. Sanitising at the write path covers every route in and every future integration
 * by construction. Sanitising at render instead would leave the stored value hostile and make each
 * consumer — the site, an export, a future MCP server — responsible for remembering.
 *
 * **Why in-tree rather than a dependency.** The usual choices do not fit the runtime: DOMPurify
 * needs a real DOM, and the jsdom-backed wrappers cannot run on Workers, which is the production
 * target.
 *
 * **Why it is safe.** This is an allowlist *serialiser*, not a filter. It parses to a token stream
 * and re-emits only constructs it understands, escaping all text and rebuilding every attribute.
 * Nothing travels from input to output as a substring. Anything it cannot parse becomes nothing,
 * never itself — which is the property that makes the failure mode safe.
 *
 * It is deliberately not a general-purpose HTML cleaner; it handles the small grammar a richtext
 * editor produces.
 */
export interface SanitizeOptions {
    /**
     * Restrict the allowlist further, e.g. `['strong', 'em', 'a']` for an inline-only field.
     * Tags outside the set are unwrapped: their text survives, the element does not.
     */
    allowedTags?: readonly string[];
}
export declare function sanitizeHtml(input: string, options?: SanitizeOptions): string;
export type HtmlToken = {
    kind: 'text';
    value: string;
} | {
    kind: 'open';
    name: string;
    attributes: string;
} | {
    kind: 'close';
    name: string;
} | {
    kind: 'other';
};
/**
 * Split HTML into a token stream.
 *
 * Strict on purpose: a `<` that does not begin something tag-shaped is emitted as literal text and
 * escaped downstream, which is what browsers do and what stops `< script>`-style tricks.
 *
 * Exported because the accessibility checker walks the same stored HTML looking for heading order
 * and link text. A second parser — a regex over `<h[2-4]>`, say — would be a second answer to "what
 * does this markup say", and the one that has been attacked in tests is this one.
 */
export declare function tokenize(input: string): Generator<HtmlToken>;
/**
 * Return the URL if its scheme is safe, otherwise null.
 *
 * Relative URLs (`/about`, `#section`, `?page=2`) are kept — they carry no scheme, and internal
 * links are the common case. Anything with an explicit scheme must be one of the four allowed.
 *
 * The scheme is tested against a copy with control characters and whitespace removed, because
 * `java\tscript:` and `java&#0;script:` are both parsed as `javascript:` by browsers but would slip
 * past a test on the literal text. Those characters are then stripped from what is returned, so the
 * value that reaches the page is the value that was checked.
 */
/**
 * The one answer to "is this safe to put in an `href`".
 *
 * Exported because the `link` field type validates an address on write and must not grow a second
 * opinion about `javascript:` — a rule that exists twice is a rule that will disagree with itself
 * once. Note it *does* admit `taproot:` references; a caller that only wants a real URL has to
 * exclude them itself, which is what the link field's `url` variant does.
 */
export declare function safeUrl(value: string): string | null;
/**
 * Plain text of a richtext value, for excerpts, search indexing, and length checks.
 *
 * Tags become a space so `<p>a</p><p>b</p>` reads as two words rather than one.
 */
export declare function htmlToText(html: string): string;