/**
 * Shared character-level CSS scanning helpers for the at-rule block
 * parsers (`@token`, `@theme`, `@style`, `@quantize`).
 *
 * Real-world CSS reaching the transform pipeline is often re-serialized
 * by upstream compilers (the Astro compiler emits a whole `<style>` as a
 * single line, with at-rules mid-line and `name{` without spaces), so
 * the parsers cannot rely on line structure. These helpers scan
 * character-by-character with comment / quoted-string / functional-
 * notation awareness.
 *
 * @module
 */
/**
 * Blank out block comments, quoted-string contents, and unquoted
 * `url(...)` contents while preserving every newline AND every
 * character offset (blanked characters become spaces).
 *
 * This produces the marker-locating copy of a stylesheet: at-rule
 * markers (`@token`, `@theme`, `@style`, `@quantize`) are searched on the blanked
 * copy so neither commented-out blocks nor marker text embedded in
 * string values (`content: "@token accent {"`) nor data URLs
 * (`url(data:...@quantize...)`) ever match as real blocks. Because
 * offsets are preserved, every match index maps 1:1 back onto the
 * original source, which the body parsers then read directly — real
 * string values inside block bodies are never altered.
 *
 * A single character-level pass handles the interleavings a sequential
 * regex approach gets wrong: quote characters inside comments do not
 * open strings, and comment markers inside strings do not open comments.
 */
export declare function blankCssCommentsAndStrings(css: string): string;
/** 1-based line number of a character offset. */
export declare function lineOfOffset(css: string, offset: number): number;
/** Advance past whitespace and block comments, returning the new position. */
export declare function skipWsAndComments(css: string, pos: number): number;
/**
 * Offset immediately after a stylesheet's leading at-rule prologue: the
 * run of `@charset`, `@import`, `@namespace`, and statement-form
 * `@layer` rules that the CSS spec requires to precede all style rules.
 * Block-form `@layer name { ... }` ends the prologue (a `{` before the
 * terminating `;`), as does any other rule or declaration.
 *
 * Pass the comment/string-blanked copy of the sheet (see
 * {@link blankCssCommentsAndStrings}) so `@import` text inside comments
 * or string values never counts as a prologue rule. Returned offsets map
 * 1:1 onto the original source.
 *
 * Used to insert generated sheet-level rules (e.g. the `:root` viewport
 * containment rule) AFTER the prologue — a style rule placed ahead of
 * `@charset` / `@import` invalidates them (browsers ignore misplaced
 * imports).
 */
export declare function cssPrologueEnd(blanked: string): number;
/**
 * Parse all flat property declarations inside a block starting at `pos`
 * (the character immediately after the opening `{`).
 *
 * Uses character-level scanning so multi-line values -- e.g.
 *   background: linear-gradient(
 *     to bottom,
 *     red,
 *     blue
 *   );
 * -- are collected as a single declaration before matching.
 *
 * Tracks paren depth so commas/semicolons inside functional notation
 * (var(), calc(), linear-gradient(), etc.) are not treated as delimiters.
 * Tracks brace depth so values containing braces (e.g. `var(--x, empty)`)
 * do not prematurely close the block. Skips block comments and quoted
 * strings (including escapes).
 *
 * @param css - Full CSS source text
 * @param pos - Position immediately after the block's opening `{`
 * @param propPattern - Override for the accepted property-name pattern
 * @returns The parsed properties and the position immediately after the
 *          closing `}` of the block.
 */
export declare function parseFlatDeclarations(css: string, pos: number, propPattern?: RegExp): {
    props: Record<string, string>;
    end: number;
};
/**
 * Skip one non-declaration segment at the current position: scans until
 * `{`, `;`, or `}` at paren depth 0 (comment / string aware). A `{`
 * opens a balanced block that is skipped entirely; a `;` is consumed; a
 * `}` is left for the caller (it closes the enclosing block).
 *
 * Used to step over nested non-state wrappers (e.g. a stray `@supports`
 * block) without aborting the surrounding at-rule parse.
 */
export declare function skipSegment(css: string, pos: number): number;
/**
 * Running brace depth over a blanked source range. At-rule scans use this
 * to accept `@token`/`@quantize`/`@style` markers only at the sheet's top
 * level (depth 0): a marker inside a declaration value — e.g. a custom
 * property holding a snippet, `--x: @style card { ... };` — is value text,
 * not an at-rule, and splicing it would corrupt the declaration. Callers
 * advance incrementally (`depth = braceDepthDelta(blanked, from, to, depth)`)
 * so a multi-match scan stays linear. Operates on BLANKED source: braces
 * inside comments and strings are already spaces there.
 */
export declare function braceDepthDelta(blanked: string, from: number, to: number, depth: number): number;
//# sourceMappingURL=css-scan.d.ts.map