Grcov report - ua

1

//! User-Agent Default Stylesheet for Azul

2

//!

3

//! This module provides the default CSS styling that browsers apply to HTML elements

4

//! before any author stylesheets are processed. It ensures consistent baseline behavior

5

//! across all applications.

6

//!

7

//! The user-agent stylesheet serves several critical functions:

8

//!

9

//! 1. **Prevents Layout Collapse**: Ensures root elements (`<html>`, `<body>`) have default

10

//!    dimensions so that percentage-based child sizing can work correctly.

11

//!

12

//! 2. **Establishes Display Types**: Defines the default `display` property for all HTML elements

13

//!    (e.g., `<div>` is `block`, `<span>` is `inline`).

14

//!

15

//! 3. **Provides Baseline Typography**: Sets reasonable defaults for font sizes, margins, and text

16

//!    styling for headings, paragraphs, and other text elements.

17

//!

18

//! 4. **Normalizes Browser Behavior**: Incorporates principles from normalize.css to provide

19

//!    consistent rendering across different platforms.

20

//!

21

//! # Licensing

22

//!

23

//! Based on principles from [normalize.css](https://github.com/necolas/normalize.css)

24

//! (MIT License, Copyright Nicolas Gallagher and Jonathan Neal).

25

//! This is NOT a direct copy but incorporates its principles and approach.

26

//!

27

//! # References

28

//!

29

//! - CSS 2.1 Specification: https://www.w3.org/TR/CSS21/

30

//! - HTML Living Standard: https://html.spec.whatwg.org/

31

//! - normalize.css: https://necolas.github.io/normalize.css/

32

33

use azul_css::{

34

    css::CssPropertyValue,

35

    dynamic_selector::{

36

        CssPropertyWithConditions,

37

        DynamicSelector, DynamicSelectorContext, OsCondition, ThemeCondition,

38

},

39

    props::{

40

        basic::{

41

            font::StyleFontWeight, pixel::PixelValue, ColorU,

42

            StyleFontSize,

43

},

44

        layout::{

45

            dimensions::{LayoutHeight, LayoutWidth},

46

            display::LayoutDisplay,

47

            fragmentation::{BreakInside, PageBreak},

48

            spacing::{

49

                LayoutMarginBottom, LayoutMarginLeft, LayoutMarginRight, LayoutMarginTop,

50

                LayoutPaddingBottom, LayoutPaddingInlineEnd, LayoutPaddingInlineStart,

51

                LayoutPaddingLeft, LayoutPaddingRight, LayoutPaddingTop,

52

},

53

},

54

        property::{CssProperty, CssPropertyType},

55

        style::{

56

            border::{

57

                BorderStyle,

58

                LayoutBorderBottomWidth, LayoutBorderLeftWidth, LayoutBorderRightWidth, LayoutBorderTopWidth,

59

                StyleBorderBottomColor, StyleBorderBottomStyle,

60

                StyleBorderLeftColor, StyleBorderLeftStyle,

61

                StyleBorderRightColor, StyleBorderRightStyle,

62

                StyleBorderTopColor, StyleBorderTopStyle,

63

},

64

            content::CounterReset,

65

            effects::StyleCursor,

66

            lists::StyleListStyleType,

67

            scrollbar::{

68

                LayoutScrollbarWidth, ScrollbarColorCustom, ScrollbarFadeDelay,

69

                ScrollbarFadeDuration, ScrollbarVisibilityMode, StyleScrollbarColor,

70

},

71

            text::StyleTextDecoration,

72

            StyleTextAlign, StyleVerticalAlign,

73

},

74

},

75

};

76

77

use crate::dom::NodeType;

78

79

/// 100% width

80

static WIDTH_100_PERCENT: CssProperty = CssProperty::Width(CssPropertyValue::Exact(

81

    LayoutWidth::Px(PixelValue::const_percent(100)),

82

));

83

84

/// 100% height

85

static HEIGHT_100_PERCENT: CssProperty = CssProperty::Height(CssPropertyValue::Exact(

86

    LayoutHeight::Px(PixelValue::const_percent(100)),

87

));

88

89

/// display: block

90

static DISPLAY_BLOCK: CssProperty =

91

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::Block));

92

static OVERFLOW_X_AUTO: CssProperty = CssProperty::OverflowX(CssPropertyValue::Exact(

93

    azul_css::props::layout::LayoutOverflow::Auto,

94

));

95

static OVERFLOW_Y_AUTO: CssProperty = CssProperty::OverflowY(CssPropertyValue::Exact(

96

    azul_css::props::layout::LayoutOverflow::Auto,

97

));

98

99

/// display: inline

100

static DISPLAY_INLINE: CssProperty =

101

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::Inline));

102

103

/// display: inline-block

104

static DISPLAY_INLINE_BLOCK: CssProperty =

105

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::InlineBlock));

106

107

/// display: none

108

static DISPLAY_NONE: CssProperty =

109

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::None));

110

111

/// break-before: page (the canonical `<pagebreak/>` element)

112

static BREAK_BEFORE_PAGE: CssProperty = CssProperty::BreakBefore(CssPropertyValue::Exact(

113

    PageBreak::Page,

114

));

115

116

/// display: table

117

static DISPLAY_TABLE: CssProperty =

118

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::Table));

119

120

/// display: table-row

121

static DISPLAY_TABLE_ROW: CssProperty =

122

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::TableRow));

123

124

/// display: table-cell

125

static DISPLAY_TABLE_CELL: CssProperty =

126

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::TableCell));

127

128

/// display: table-header-group

129

static DISPLAY_TABLE_HEADER_GROUP: CssProperty =

130

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::TableHeaderGroup));

131

132

/// display: table-row-group

133

static DISPLAY_TABLE_ROW_GROUP: CssProperty =

134

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::TableRowGroup));

135

136

/// display: table-footer-group

137

static DISPLAY_TABLE_FOOTER_GROUP: CssProperty =

138

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::TableFooterGroup));

139

140

/// display: table-caption

141

static DISPLAY_TABLE_CAPTION: CssProperty =

142

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::TableCaption));

143

144

/// display: table-column-group

145

static DISPLAY_TABLE_COLUMN_GROUP: CssProperty =

146

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::TableColumnGroup));

147

148

/// display: table-column

149

static DISPLAY_TABLE_COLUMN: CssProperty =

150

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::TableColumn));

151

152

/// display: list-item

153

static DISPLAY_LIST_ITEM: CssProperty =

154

    CssProperty::Display(CssPropertyValue::Exact(LayoutDisplay::ListItem));

155

156

/// cursor: pointer (for clickable elements like buttons, links)

157

static CURSOR_POINTER: CssProperty =

158

    CssProperty::Cursor(CssPropertyValue::Exact(StyleCursor::Pointer));

159

160

/// cursor: text (for selectable text elements)

161

static CURSOR_TEXT: CssProperty =

162

    CssProperty::Cursor(CssPropertyValue::Exact(StyleCursor::Text));

163

164

/// margin-top: 0

165

static MARGIN_TOP_ZERO: CssProperty =

166

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

167

        inner: PixelValue::const_px(0),

168

    }));

169

170

/// margin-bottom: 0

171

static MARGIN_BOTTOM_ZERO: CssProperty =

172

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

173

        inner: PixelValue::const_px(0),

174

    }));

175

176

/// margin-left: 0

177

static MARGIN_LEFT_ZERO: CssProperty =

178

    CssProperty::MarginLeft(CssPropertyValue::Exact(LayoutMarginLeft {

179

        inner: PixelValue::const_px(0),

180

    }));

181

182

/// margin-right: 0

183

static MARGIN_RIGHT_ZERO: CssProperty =

184

    CssProperty::MarginRight(CssPropertyValue::Exact(LayoutMarginRight {

185

        inner: PixelValue::const_px(0),

186

    }));

187

188

// Chrome User-Agent Stylesheet: body { margin: 8px; }

189

/// margin-top: 8px (Chrome UA default for body)

190

static MARGIN_TOP_8PX: CssProperty =

191

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

192

        inner: PixelValue::const_px(8),

193

    }));

194

195

/// margin-bottom: 8px (Chrome UA default for body)

196

static MARGIN_BOTTOM_8PX: CssProperty =

197

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

198

        inner: PixelValue::const_px(8),

199

    }));

200

201

/// margin-left: 8px (Chrome UA default for body)

202

static MARGIN_LEFT_8PX: CssProperty =

203

    CssProperty::MarginLeft(CssPropertyValue::Exact(LayoutMarginLeft {

204

        inner: PixelValue::const_px(8),

205

    }));

206

207

/// margin-right: 8px (Chrome UA default for body)

208

static MARGIN_RIGHT_8PX: CssProperty =

209

    CssProperty::MarginRight(CssPropertyValue::Exact(LayoutMarginRight {

210

        inner: PixelValue::const_px(8),

211

    }));

212

213

/// font-size: 2em (for H1)

214

static FONT_SIZE_2EM: CssProperty = CssProperty::FontSize(CssPropertyValue::Exact(StyleFontSize {

215

    inner: PixelValue::const_em(2),

216

}));

217

218

/// font-size: 1.5em (for H2)

219

static FONT_SIZE_1_5EM: CssProperty =

220

    CssProperty::FontSize(CssPropertyValue::Exact(StyleFontSize {

221

        inner: PixelValue::const_em_fractional(1, 5),

222

    }));

223

224

/// font-size: 1.17em (for H3)

225

static FONT_SIZE_1_17EM: CssProperty =

226

    CssProperty::FontSize(CssPropertyValue::Exact(StyleFontSize {

227

        inner: PixelValue::const_em_fractional(1, 17),

228

    }));

229

230

/// font-size: 1em (for H4)

231

static FONT_SIZE_1EM: CssProperty = CssProperty::FontSize(CssPropertyValue::Exact(StyleFontSize {

232

    inner: PixelValue::const_em(1),

233

}));

234

235

/// font-size: 0.83em (for H5)

236

static FONT_SIZE_0_83EM: CssProperty =

237

    CssProperty::FontSize(CssPropertyValue::Exact(StyleFontSize {

238

        inner: PixelValue::const_em_fractional(0, 83),

239

    }));

240

241

/// font-size: 0.67em (for H6)

242

static FONT_SIZE_0_67EM: CssProperty =

243

    CssProperty::FontSize(CssPropertyValue::Exact(StyleFontSize {

244

        inner: PixelValue::const_em_fractional(0, 67),

245

    }));

246

247

/// margin-top: 1em (for P)

248

static MARGIN_TOP_1EM: CssProperty =

249

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

250

        inner: PixelValue::const_em(1),

251

    }));

252

253

/// margin-bottom: 1em (for P)

254

static MARGIN_BOTTOM_1EM: CssProperty =

255

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

256

        inner: PixelValue::const_em(1),

257

    }));

258

259

/// margin-top: 0.67em (for H1)

260

static MARGIN_TOP_0_67EM: CssProperty =

261

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

262

        inner: PixelValue::const_em_fractional(0, 67),

263

    }));

264

265

/// margin-bottom: 0.67em (for H1)

266

static MARGIN_BOTTOM_0_67EM: CssProperty =

267

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

268

        inner: PixelValue::const_em_fractional(0, 67),

269

    }));

270

271

/// margin-top: 0.83em (for H2)

272

static MARGIN_TOP_0_83EM: CssProperty =

273

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

274

        inner: PixelValue::const_em_fractional(0, 83),

275

    }));

276

277

/// margin-bottom: 0.83em (for H2)

278

static MARGIN_BOTTOM_0_83EM: CssProperty =

279

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

280

        inner: PixelValue::const_em_fractional(0, 83),

281

    }));

282

283

/// margin-top: 1.33em (for H4)

284

static MARGIN_TOP_1_33EM: CssProperty =

285

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

286

        inner: PixelValue::const_em_fractional(1, 33),

287

    }));

288

289

/// margin-bottom: 1.33em (for H4)

290

static MARGIN_BOTTOM_1_33EM: CssProperty =

291

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

292

        inner: PixelValue::const_em_fractional(1, 33),

293

    }));

294

295

/// margin-top: 1.67em (for H5)

296

static MARGIN_TOP_1_67EM: CssProperty =

297

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

298

        inner: PixelValue::const_em_fractional(1, 67),

299

    }));

300

301

/// margin-bottom: 1.67em (for H5)

302

static MARGIN_BOTTOM_1_67EM: CssProperty =

303

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

304

        inner: PixelValue::const_em_fractional(1, 67),

305

    }));

306

307

/// margin-top: 2.33em (for H6)

308

static MARGIN_TOP_2_33EM: CssProperty =

309

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

310

        inner: PixelValue::const_em_fractional(2, 33),

311

    }));

312

313

/// margin-bottom: 2.33em (for H6)

314

static MARGIN_BOTTOM_2_33EM: CssProperty =

315

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

316

        inner: PixelValue::const_em_fractional(2, 33),

317

    }));

318

319

/// font-weight: bold (for headings)

320

static FONT_WEIGHT_BOLD: CssProperty =

321

    CssProperty::FontWeight(CssPropertyValue::Exact(StyleFontWeight::Bold));

322

323

/// font-weight: bolder

324

static FONT_WEIGHT_BOLDER: CssProperty =

325

    CssProperty::FontWeight(CssPropertyValue::Exact(StyleFontWeight::Bolder));

326

327

// Table cell padding - Chrome UA CSS default: 1px

328

static PADDING_TOP_1PX: CssProperty =

329

    CssProperty::PaddingTop(CssPropertyValue::Exact(LayoutPaddingTop {

330

        inner: PixelValue::const_px(1),

331

    }));

332

333

static PADDING_BOTTOM_1PX: CssProperty =

334

    CssProperty::PaddingBottom(CssPropertyValue::Exact(LayoutPaddingBottom {

335

        inner: PixelValue::const_px(1),

336

    }));

337

338

static PADDING_LEFT_1PX: CssProperty =

339

    CssProperty::PaddingLeft(CssPropertyValue::Exact(LayoutPaddingLeft {

340

        inner: PixelValue::const_px(1),

341

    }));

342

343

static PADDING_RIGHT_1PX: CssProperty =

344

    CssProperty::PaddingRight(CssPropertyValue::Exact(LayoutPaddingRight {

345

        inner: PixelValue::const_px(1),

346

    }));

347

348

/// text-align: center (for th elements)

349

static TEXT_ALIGN_CENTER: CssProperty =

350

    CssProperty::TextAlign(CssPropertyValue::Exact(StyleTextAlign::Center));

351

352

/// vertical-align: middle (for table elements)

353

static VERTICAL_ALIGN_MIDDLE: CssProperty =

354

    CssProperty::VerticalAlign(CssPropertyValue::Exact(StyleVerticalAlign::Middle));

355

356

/// list-style-type: disc (default for <ul>)

357

static LIST_STYLE_TYPE_DISC: CssProperty =

358

    CssProperty::ListStyleType(CssPropertyValue::Exact(StyleListStyleType::Disc));

359

360

/// list-style-type: decimal (default for <ol>)

361

static LIST_STYLE_TYPE_DECIMAL: CssProperty =

362

    CssProperty::ListStyleType(CssPropertyValue::Exact(StyleListStyleType::Decimal));

363

364

// --- HR Element Defaults ---

365

// Per HTML spec, <hr> renders as a horizontal line with inset border style

366

367

/// margin-top: 0.5em (for hr)

368

static MARGIN_TOP_0_5EM: CssProperty =

369

    CssProperty::MarginTop(CssPropertyValue::Exact(LayoutMarginTop {

370

        inner: PixelValue::const_em_fractional(0, 5),

371

    }));

372

373

/// margin-bottom: 0.5em (for hr)

374

static MARGIN_BOTTOM_0_5EM: CssProperty =

375

    CssProperty::MarginBottom(CssPropertyValue::Exact(LayoutMarginBottom {

376

        inner: PixelValue::const_em_fractional(0, 5),

377

    }));

378

379

/// border-top-style: inset (for hr - default browser style)

380

static BORDER_TOP_STYLE_INSET: CssProperty =

381

    CssProperty::BorderTopStyle(CssPropertyValue::Exact(StyleBorderTopStyle {

382

        inner: BorderStyle::Inset,

383

    }));

384

385

/// border-top-width: 1px (for hr)

386

static BORDER_TOP_WIDTH_1PX: CssProperty =

387

    CssProperty::BorderTopWidth(CssPropertyValue::Exact(LayoutBorderTopWidth {

388

        inner: PixelValue::const_px(1),

389

    }));

390

391

/// border-top-color: gray (for hr - default visible color)

392

static BORDER_TOP_COLOR_GRAY: CssProperty =

393

    CssProperty::BorderTopColor(CssPropertyValue::Exact(StyleBorderTopColor {

394

        inner: ColorU {

395

            r: 128,

396

            g: 128,

397

            b: 128,

398

            a: 255,

399

},

400

    }));

401

402

/// height: 0 (for hr - the line comes from the border, not height)

403

static HEIGHT_ZERO: CssProperty = CssProperty::Height(CssPropertyValue::Exact(LayoutHeight::Px(

404

    PixelValue::const_px(0),

405

)));

406

407

/// counter-reset: list-item 0 (default for <ul>, <ol>)

408

/// Per CSS Lists Module Level 3, list containers automatically reset the list-item counter

409

static COUNTER_RESET_LIST_ITEM: CssProperty =

410

    CssProperty::CounterReset(CssPropertyValue::Exact(CounterReset::list_item()));

411

412

// CSS Fragmentation (Page Breaking) Properties

413

//

414

// Per CSS Fragmentation Level 3 and paged media best practices,

415

// certain elements should avoid page breaks inside them

416

417

/// break-inside: avoid

418

/// Used for elements that should not be split across page boundaries

419

/// Applied to: h1-h6, table, thead, tbody, tfoot, figure, figcaption

420

static BREAK_INSIDE_AVOID: CssProperty = CssProperty::break_inside(BreakInside::Avoid);

421

422

/// break-after: avoid

423

/// Avoids a page break after the element (useful for headings)

424

static BREAK_AFTER_AVOID: CssProperty = CssProperty::break_after(PageBreak::Avoid);

425

426

/// padding-inline-start: 40px (default for <li>)

427

///

428

/// Creates space for list markers in the inline-start direction (left in LTR, right in RTL)

429

/// padding-inline-start: 40px for list items per CSS Lists Module Level 3

430

/// Applied to <li> items to create gutter space for `::marker` pseudo-elements

431

///

432

/// NOTE: This should be on the list items, not the container, because:

433

///

434

/// 1. `::marker` pseudo-elements are children of <li>, not <ul>/<ol>

435

/// 2. The marker needs to be positioned relative to the list item's content box

436

/// 3. Padding on <li> creates space between the marker and the text content

437

///    TODO: Change to `PaddingInlineStart` once logical property resolution is implemented

438

static PADDING_INLINE_START_40PX: CssProperty =

439

    CssProperty::PaddingLeft(CssPropertyValue::Exact(LayoutPaddingLeft {

440

        inner: PixelValue::const_px(40),

441

    }));

442

443

/// Text decoration: underline - used for <a> and <u> elements

444

static TEXT_DECORATION_UNDERLINE: CssProperty = CssProperty::TextDecoration(

445

    CssPropertyValue::Exact(StyleTextDecoration::Underline),

446

);

447

448

// --- Button Element Defaults ---

449

// Per browser UA CSS, <button> has padding, border, and a system font size.

450

// These ensure a button is visible even without author CSS.

451

452

/// font-size: 13px (standard button font size on macOS/Linux)

453

static FONT_SIZE_13PX: CssProperty = CssProperty::FontSize(CssPropertyValue::Exact(StyleFontSize {

454

    inner: PixelValue::const_px(13),

455

}));

456

457

/// padding-top: 5px (button)

458

static PADDING_TOP_5PX: CssProperty =

459

    CssProperty::PaddingTop(CssPropertyValue::Exact(LayoutPaddingTop {

460

        inner: PixelValue::const_px(5),

461

    }));

462

463

/// padding-bottom: 5px (button)

464

static PADDING_BOTTOM_5PX: CssProperty =

465

    CssProperty::PaddingBottom(CssPropertyValue::Exact(LayoutPaddingBottom {

466

        inner: PixelValue::const_px(5),

467

    }));

468

469

/// padding-left: 10px (button)

470

static PADDING_LEFT_10PX: CssProperty =

471

    CssProperty::PaddingLeft(CssPropertyValue::Exact(LayoutPaddingLeft {

472

        inner: PixelValue::const_px(10),

473

    }));

474

475

/// padding-right: 10px (button)

476

static PADDING_RIGHT_10PX: CssProperty =

477

    CssProperty::PaddingRight(CssPropertyValue::Exact(LayoutPaddingRight {

478

        inner: PixelValue::const_px(10),

479

    }));

480

481

/// Border color for button: #c8c8c8 (light gray)

482

static BUTTON_BORDER_COLOR: ColorU = ColorU { r: 200, g: 200, b: 200, a: 255 };

483

484

static BUTTON_BORDER_TOP_COLOR: CssProperty =

485

    CssProperty::BorderTopColor(CssPropertyValue::Exact(StyleBorderTopColor {

486

        inner: BUTTON_BORDER_COLOR,

487

    }));

488

static BUTTON_BORDER_BOTTOM_COLOR: CssProperty =

489

    CssProperty::BorderBottomColor(CssPropertyValue::Exact(StyleBorderBottomColor {

490

        inner: BUTTON_BORDER_COLOR,

491

    }));

492

static BUTTON_BORDER_LEFT_COLOR: CssProperty =

493

    CssProperty::BorderLeftColor(CssPropertyValue::Exact(StyleBorderLeftColor {

494

        inner: BUTTON_BORDER_COLOR,

495

    }));

496

static BUTTON_BORDER_RIGHT_COLOR: CssProperty =

497

    CssProperty::BorderRightColor(CssPropertyValue::Exact(StyleBorderRightColor {

498

        inner: BUTTON_BORDER_COLOR,

499

    }));

500

501

static BUTTON_BORDER_TOP_STYLE: CssProperty =

502

    CssProperty::BorderTopStyle(CssPropertyValue::Exact(StyleBorderTopStyle {

503

        inner: BorderStyle::Solid,

504

    }));

505

static BUTTON_BORDER_BOTTOM_STYLE: CssProperty =

506

    CssProperty::BorderBottomStyle(CssPropertyValue::Exact(StyleBorderBottomStyle {

507

        inner: BorderStyle::Solid,

508

    }));

509

static BUTTON_BORDER_LEFT_STYLE: CssProperty =

510

    CssProperty::BorderLeftStyle(CssPropertyValue::Exact(StyleBorderLeftStyle {

511

        inner: BorderStyle::Solid,

512

    }));

513

static BUTTON_BORDER_RIGHT_STYLE: CssProperty =

514

    CssProperty::BorderRightStyle(CssPropertyValue::Exact(StyleBorderRightStyle {

515

        inner: BorderStyle::Solid,

516

    }));

517

518

static BUTTON_BORDER_TOP_WIDTH: CssProperty =

519

    CssProperty::BorderTopWidth(CssPropertyValue::Exact(LayoutBorderTopWidth {

520

        inner: PixelValue::const_px(1),

521

    }));

522

static BUTTON_BORDER_BOTTOM_WIDTH: CssProperty =

523

    CssProperty::BorderBottomWidth(CssPropertyValue::Exact(LayoutBorderBottomWidth {

524

        inner: PixelValue::const_px(1),

525

    }));

526

static BUTTON_BORDER_LEFT_WIDTH: CssProperty =

527

    CssProperty::BorderLeftWidth(CssPropertyValue::Exact(LayoutBorderLeftWidth {

528

        inner: PixelValue::const_px(1),

529

    }));

530

static BUTTON_BORDER_RIGHT_WIDTH: CssProperty =

531

    CssProperty::BorderRightWidth(CssPropertyValue::Exact(LayoutBorderRightWidth {

532

        inner: PixelValue::const_px(1),

533

    }));

534

535

/// Returns the default user-agent CSS property value for a given node type and property.

536

///

537

/// This function provides the baseline styling that should be applied before any author

538

/// styles. It ensures that elements have sensible defaults that prevent layout issues.

539

///

540

/// # Arguments

541

///

542

/// * `node_type` - The type of DOM node (e.g., `Body`, `H1`, `Div`)

543

/// * `property_type` - The specific CSS property to query (e.g., `Width`, `Display`)

544

///

545

/// # Returns

546

///

547

/// `Some(CssProperty)` if a default value is defined for this combination, otherwise `None`.

548

// Exhaustive (node-type, property-type) → default-value lookup table: many

549

// element types share a default (e.g. all block elements → DISPLAY_BLOCK). One

550

// arm per (NT, PT) case is intentional for readability; merging into giant

551

// or-patterns would collapse the UA stylesheet table.

552

#[allow(clippy::match_same_arms)]

553

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose parser/builder/dispatch (one branch per input variant)

554

76473917

#[must_use] pub fn get_ua_property(

555

76473917

    node_type: &NodeType,

556

76473917

    property_type: CssPropertyType,

557

76473917

) -> Option<&'static CssProperty> {

558

    use CssPropertyType as PT;

559

    use NodeType as NT;

560

561

562

563

76473917

    match (node_type, property_type) {

564

        // Body Element - CRITICAL for preventing layout collapse

565

35973

        (NT::Body, PT::Display) => Some(&DISPLAY_BLOCK),

566

        // NOTE: Body does NOT have width: 100% in standard UA CSS - it inherits from ICB

567

        // (NT::Body, PT::Height) => Some(&HEIGHT_100_PERCENT),

568

33450

        (NT::Body, PT::MarginTop) => Some(&MARGIN_TOP_8PX),

569

33431

        (NT::Body, PT::MarginBottom) => Some(&MARGIN_BOTTOM_8PX),

570

33431

        (NT::Body, PT::MarginLeft) => Some(&MARGIN_LEFT_8PX),

571

33431

        (NT::Body, PT::MarginRight) => Some(&MARGIN_RIGHT_8PX),

572

573

        // Block-level Elements

574

        // NOTE: Do NOT set width: 100% here! Block elements have width: auto by default

575

        // in CSS spec. width: auto for blocks means "fill available width" but it's NOT

576

        // the same as width: 100%. The difference is critical for flexbox: width: auto

577

        // allows flex-grow/flex-shrink to control sizing, while width: 100% prevents it.

578

445018

        (NT::Div, PT::Display) => Some(&DISPLAY_BLOCK),

579

313109

        (NT::P, PT::Display) => Some(&DISPLAY_BLOCK),

580

        // REMOVED - blocks have width: auto by default

581

        // (NT::Div, PT::Width) => Some(&WIDTH_100_PERCENT),

582

        // REMOVED - blocks have width: auto by default

583

        // (NT::P, PT::Width) => Some(&WIDTH_100_PERCENT),

584

329858

        (NT::P, PT::MarginTop) => Some(&MARGIN_TOP_1EM),

585

325766

        (NT::P, PT::MarginBottom) => Some(&MARGIN_BOTTOM_1EM),

586

5

        (NT::Main, PT::Display) => Some(&DISPLAY_BLOCK),

587

4

        (NT::Header, PT::Display) => Some(&DISPLAY_BLOCK),

588

4

        (NT::Footer, PT::Display) => Some(&DISPLAY_BLOCK),

589

43

        (NT::Section, PT::Display) => Some(&DISPLAY_BLOCK),

590

42

        (NT::Article, PT::Display) => Some(&DISPLAY_BLOCK),

591

4

        (NT::Aside, PT::Display) => Some(&DISPLAY_BLOCK),

592

4

        (NT::Nav, PT::Display) => Some(&DISPLAY_BLOCK),

593

594

        // Headings - Chrome UA CSS values

595

        // Per CSS Fragmentation Level 3: headings should avoid page breaks inside

596

        // and after them (to keep heading with following content)

597

1493

        (NT::H1, PT::Display) => Some(&DISPLAY_BLOCK),

598

876

        (NT::H1, PT::FontSize) => Some(&FONT_SIZE_2EM),

599

1492

        (NT::H1, PT::FontWeight) => Some(&FONT_WEIGHT_BOLD),

600

1440

        (NT::H1, PT::MarginTop) => Some(&MARGIN_TOP_0_67EM),

601

846

        (NT::H1, PT::MarginBottom) => Some(&MARGIN_BOTTOM_0_67EM),

602

748

        (NT::H1, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

603

748

        (NT::H1, PT::BreakAfter) => Some(&BREAK_AFTER_AVOID),

604

605

445

        (NT::H2, PT::Display) => Some(&DISPLAY_BLOCK),

606

224

        (NT::H2, PT::FontSize) => Some(&FONT_SIZE_1_5EM),

607

444

        (NT::H2, PT::FontWeight) => Some(&FONT_WEIGHT_BOLD),

608

356

        (NT::H2, PT::MarginTop) => Some(&MARGIN_TOP_0_83EM),

609

224

        (NT::H2, PT::MarginBottom) => Some(&MARGIN_BOTTOM_0_83EM),

610

224

        (NT::H2, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

611

224

        (NT::H2, PT::BreakAfter) => Some(&BREAK_AFTER_AVOID),

612

613

49

        (NT::H3, PT::Display) => Some(&DISPLAY_BLOCK),

614

26

        (NT::H3, PT::FontSize) => Some(&FONT_SIZE_1_17EM),

615

48

        (NT::H3, PT::FontWeight) => Some(&FONT_WEIGHT_BOLD),

616

26

        (NT::H3, PT::MarginTop) => Some(&MARGIN_TOP_1EM),

617

26

        (NT::H3, PT::MarginBottom) => Some(&MARGIN_BOTTOM_1EM),

618

26

        (NT::H3, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

619

26

        (NT::H3, PT::BreakAfter) => Some(&BREAK_AFTER_AVOID),

620

621

5

        (NT::H4, PT::Display) => Some(&DISPLAY_BLOCK),

622

4

        (NT::H4, PT::FontSize) => Some(&FONT_SIZE_1EM),

623

4

        (NT::H4, PT::FontWeight) => Some(&FONT_WEIGHT_BOLD),

624

4

        (NT::H4, PT::MarginTop) => Some(&MARGIN_TOP_1_33EM),

625

4

        (NT::H4, PT::MarginBottom) => Some(&MARGIN_BOTTOM_1_33EM),

626

4

        (NT::H4, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

627

4

        (NT::H4, PT::BreakAfter) => Some(&BREAK_AFTER_AVOID),

628

629

5

        (NT::H5, PT::Display) => Some(&DISPLAY_BLOCK),

630

4

        (NT::H5, PT::FontSize) => Some(&FONT_SIZE_0_83EM),

631

4

        (NT::H5, PT::FontWeight) => Some(&FONT_WEIGHT_BOLD),

632

4

        (NT::H5, PT::MarginTop) => Some(&MARGIN_TOP_1_67EM),

633

4

        (NT::H5, PT::MarginBottom) => Some(&MARGIN_BOTTOM_1_67EM),

634

4

        (NT::H5, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

635

4

        (NT::H5, PT::BreakAfter) => Some(&BREAK_AFTER_AVOID),

636

637

5

        (NT::H6, PT::Display) => Some(&DISPLAY_BLOCK),

638

4

        (NT::H6, PT::FontSize) => Some(&FONT_SIZE_0_67EM),

639

4

        (NT::H6, PT::FontWeight) => Some(&FONT_WEIGHT_BOLD),

640

4

        (NT::H6, PT::MarginTop) => Some(&MARGIN_TOP_2_33EM),

641

4

        (NT::H6, PT::MarginBottom) => Some(&MARGIN_BOTTOM_2_33EM),

642

4

        (NT::H6, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

643

4

        (NT::H6, PT::BreakAfter) => Some(&BREAK_AFTER_AVOID),

644

645

        // Lists - padding on container creates gutter for markers

646

1369

        (NT::Ul, PT::Display) => Some(&DISPLAY_BLOCK),

647

1368

        (NT::Ul, PT::ListStyleType) => Some(&LIST_STYLE_TYPE_DISC),

648

1368

        (NT::Ul, PT::CounterReset) => Some(&COUNTER_RESET_LIST_ITEM),

649

1368

        (NT::Ul, PT::PaddingLeft) => Some(&PADDING_INLINE_START_40PX),

650

1367

        (NT::Ul, PT::MarginTop) => Some(&MARGIN_TOP_1EM),

651

751

        (NT::Ul, PT::MarginBottom) => Some(&MARGIN_BOTTOM_1EM),

652

5

        (NT::Ol, PT::Display) => Some(&DISPLAY_BLOCK),

653

4

        (NT::Ol, PT::ListStyleType) => Some(&LIST_STYLE_TYPE_DECIMAL),

654

4

        (NT::Ol, PT::CounterReset) => Some(&COUNTER_RESET_LIST_ITEM),

655

4

        (NT::Ol, PT::PaddingLeft) => Some(&PADDING_INLINE_START_40PX),

656

3

        (NT::Ol, PT::MarginTop) => Some(&MARGIN_TOP_1EM),

657

3

        (NT::Ol, PT::MarginBottom) => Some(&MARGIN_BOTTOM_1EM),

658

4075

        (NT::Li, PT::Display) => Some(&DISPLAY_LIST_ITEM),

659

4

        (NT::Dl, PT::Display) => Some(&DISPLAY_BLOCK),

660

4

        (NT::Dt, PT::Display) => Some(&DISPLAY_BLOCK),

661

4

        (NT::Dd, PT::Display) => Some(&DISPLAY_BLOCK),

662

663

        // Inline Elements

664

2552

        (NT::Span, PT::Display) => Some(&DISPLAY_INLINE),

665

1632

        (NT::A, PT::Display) => Some(&DISPLAY_INLINE),

666

1632

        (NT::A, PT::TextDecoration) => Some(&TEXT_DECORATION_UNDERLINE),

667

48

        (NT::Strong, PT::Display) => Some(&DISPLAY_INLINE),

668

26

        (NT::Strong, PT::FontWeight) => Some(&FONT_WEIGHT_BOLDER),

669

70

        (NT::Em, PT::Display) => Some(&DISPLAY_INLINE),

670

4

        (NT::B, PT::Display) => Some(&DISPLAY_INLINE),

671

4

        (NT::B, PT::FontWeight) => Some(&FONT_WEIGHT_BOLDER),

672

4

        (NT::I, PT::Display) => Some(&DISPLAY_INLINE),

673

4

        (NT::U, PT::Display) => Some(&DISPLAY_INLINE),

674

4

        (NT::U, PT::TextDecoration) => Some(&TEXT_DECORATION_UNDERLINE),

675

4

        (NT::Small, PT::Display) => Some(&DISPLAY_INLINE),

676

48

        (NT::Code, PT::Display) => Some(&DISPLAY_INLINE),

677

4

        (NT::Kbd, PT::Display) => Some(&DISPLAY_INLINE),

678

4

        (NT::Samp, PT::Display) => Some(&DISPLAY_INLINE),

679

4

        (NT::Sub, PT::Display) => Some(&DISPLAY_INLINE),

680

4

        (NT::Sup, PT::Display) => Some(&DISPLAY_INLINE),

681

682

        // Text Content

683

92

        (NT::Pre, PT::Display) => Some(&DISPLAY_BLOCK),

684

48

        (NT::BlockQuote, PT::Display) => Some(&DISPLAY_BLOCK),

685

4

        (NT::Hr, PT::Display) => Some(&DISPLAY_BLOCK),

686

4

        (NT::Hr, PT::Width) => Some(&WIDTH_100_PERCENT),

687

4

        (NT::Hr, PT::Height) => Some(&HEIGHT_ZERO),

688

3

        (NT::Hr, PT::MarginTop) => Some(&MARGIN_TOP_0_5EM),

689

3

        (NT::Hr, PT::MarginBottom) => Some(&MARGIN_BOTTOM_0_5EM),

690

4

        (NT::Hr, PT::BorderTopStyle) => Some(&BORDER_TOP_STYLE_INSET),

691

4

        (NT::Hr, PT::BorderTopWidth) => Some(&BORDER_TOP_WIDTH_1PX),

692

4

        (NT::Hr, PT::BorderTopColor) => Some(&BORDER_TOP_COLOR_GRAY),

693

694

        // Table Elements

695

        // Per CSS Fragmentation Level 3: table ROWS should avoid breaks inside

696

        // Tables themselves should NOT have break-inside: avoid (they can span pages)

697

819

        (NT::Table, PT::Display) => Some(&DISPLAY_TABLE),

698

        // NOTE: Removed break-inside: avoid from Table - tables CAN break across pages

699

88

        (NT::PageBreak, PT::Display) => Some(&DISPLAY_BLOCK),

700

66

        (NT::PageBreak, PT::BreakBefore) => Some(&BREAK_BEFORE_PAGE),

701

115

        (NT::THead, PT::Display) => Some(&DISPLAY_TABLE_HEADER_GROUP),

702

113

        (NT::THead, PT::VerticalAlign) => Some(&VERTICAL_ALIGN_MIDDLE),

703

59

        (NT::THead, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

704

93

        (NT::TBody, PT::Display) => Some(&DISPLAY_TABLE_ROW_GROUP),

705

91

        (NT::TBody, PT::VerticalAlign) => Some(&VERTICAL_ALIGN_MIDDLE),

706

        // NOTE: Removed break-inside: avoid from TBody - tbody CAN break across pages

707

5

        (NT::TFoot, PT::Display) => Some(&DISPLAY_TABLE_FOOTER_GROUP),

708

3

        (NT::TFoot, PT::VerticalAlign) => Some(&VERTICAL_ALIGN_MIDDLE),

709

4

        (NT::TFoot, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

710

1303

        (NT::Tr, PT::Display) => Some(&DISPLAY_TABLE_ROW),

711

1301

        (NT::Tr, PT::VerticalAlign) => Some(&VERTICAL_ALIGN_MIDDLE),

712

653

        (NT::Tr, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

713

49

        (NT::Th, PT::Display) => Some(&DISPLAY_TABLE_CELL),

714

26

        (NT::Th, PT::TextAlign) => Some(&TEXT_ALIGN_CENTER),

715

48

        (NT::Th, PT::FontWeight) => Some(&FONT_WEIGHT_BOLD),

716

70

        (NT::Th, PT::VerticalAlign) => Some(&VERTICAL_ALIGN_MIDDLE),

717

26

        (NT::Th, PT::PaddingTop) => Some(&PADDING_TOP_1PX),

718

26

        (NT::Th, PT::PaddingBottom) => Some(&PADDING_BOTTOM_1PX),

719

26

        (NT::Th, PT::PaddingLeft) => Some(&PADDING_LEFT_1PX),

720

26

        (NT::Th, PT::PaddingRight) => Some(&PADDING_RIGHT_1PX),

721

1831

        (NT::Td, PT::Display) => Some(&DISPLAY_TABLE_CELL),

722

2743

        (NT::Td, PT::VerticalAlign) => Some(&VERTICAL_ALIGN_MIDDLE),

723

1753

        (NT::Td, PT::PaddingTop) => Some(&PADDING_TOP_1PX),

724

1753

        (NT::Td, PT::PaddingBottom) => Some(&PADDING_BOTTOM_1PX),

725

1753

        (NT::Td, PT::PaddingLeft) => Some(&PADDING_LEFT_1PX),

726

1753

        (NT::Td, PT::PaddingRight) => Some(&PADDING_RIGHT_1PX),

727

728

        // Form Elements

729

4

        (NT::Form, PT::Display) => Some(&DISPLAY_BLOCK),

730

554

        (NT::Input, PT::Display) => Some(&DISPLAY_INLINE_BLOCK),

731

36910

        (NT::Button, PT::Display) => Some(&DISPLAY_INLINE_BLOCK),

732

36965

        (NT::Button, PT::Cursor) => Some(&CURSOR_POINTER),

733

54409

        (NT::Button, PT::FontSize) => Some(&FONT_SIZE_13PX),

734

36952

        (NT::Button, PT::PaddingTop) => Some(&PADDING_TOP_5PX),

735

36952

        (NT::Button, PT::PaddingBottom) => Some(&PADDING_BOTTOM_5PX),

736

37007

        (NT::Button, PT::PaddingLeft) => Some(&PADDING_LEFT_10PX),

737

37007

        (NT::Button, PT::PaddingRight) => Some(&PADDING_RIGHT_10PX),

738

36964

        (NT::Button, PT::BorderTopWidth) => Some(&BUTTON_BORDER_TOP_WIDTH),

739

36150

        (NT::Button, PT::BorderBottomWidth) => Some(&BUTTON_BORDER_BOTTOM_WIDTH),

740

36150

        (NT::Button, PT::BorderLeftWidth) => Some(&BUTTON_BORDER_LEFT_WIDTH),

741

36150

        (NT::Button, PT::BorderRightWidth) => Some(&BUTTON_BORDER_RIGHT_WIDTH),

742

41254

        (NT::Button, PT::BorderTopStyle) => Some(&BUTTON_BORDER_TOP_STYLE),

743

36150

        (NT::Button, PT::BorderBottomStyle) => Some(&BUTTON_BORDER_BOTTOM_STYLE),

744

36150

        (NT::Button, PT::BorderLeftStyle) => Some(&BUTTON_BORDER_LEFT_STYLE),

745

36150

        (NT::Button, PT::BorderRightStyle) => Some(&BUTTON_BORDER_RIGHT_STYLE),

746

41254

        (NT::Button, PT::BorderTopColor) => Some(&BUTTON_BORDER_TOP_COLOR),

747

36150

        (NT::Button, PT::BorderBottomColor) => Some(&BUTTON_BORDER_BOTTOM_COLOR),

748

36150

        (NT::Button, PT::BorderLeftColor) => Some(&BUTTON_BORDER_LEFT_COLOR),

749

36150

        (NT::Button, PT::BorderRightColor) => Some(&BUTTON_BORDER_RIGHT_COLOR),

750

        // Text nodes get I-beam cursor for text selection

751

        // The cursor resolution algorithm ensures that explicit cursor properties

752

        // on parent elements (e.g., cursor:pointer on button) take precedence

753

419707

        (NT::Text(_), PT::Cursor) => Some(&CURSOR_TEXT),

754

554

        (NT::Select, PT::Display) => Some(&DISPLAY_INLINE_BLOCK),

755

1500

        (NT::TextArea, PT::Display) => Some(&DISPLAY_INLINE_BLOCK),

756

        // TextArea gets I-beam cursor since it's an editable text field

757

1500

        (NT::TextArea, PT::Cursor) => Some(&CURSOR_TEXT),

758

4

        (NT::Label, PT::Display) => Some(&DISPLAY_INLINE),

759

        // Hidden Elements

760

27

        (NT::Head, PT::Display) => Some(&DISPLAY_NONE),

761

5

        (NT::Title, PT::Display) => Some(&DISPLAY_NONE),

762

5

        (NT::Script, PT::Display) => Some(&DISPLAY_NONE),

763

5

        (NT::Style, PT::Display) => Some(&DISPLAY_NONE),

764

5

        (NT::Link, PT::Display) => Some(&DISPLAY_NONE),

765

766

        // Special Elements

767

        // <br> is an inline-level element that forces a line break WITHIN the

768

        // inline formatting context (HTML §4.5.28). Giving it `display: block`

769

        // made `<p>text<br>more</p>` split into three stacked block boxes (an

770

        // extra empty <br> box between two anonymous paragraphs), over-advancing

771

        // vertically and, inside a table cell, dropping the line after the break.

772

        // As inline it is turned into a hard `LineBreak` by the IFC collectors.

773

83

        (NT::Br, PT::Display) => Some(&DISPLAY_INLINE),

774

        // Images are replaced elements - inline-block so they respect width/height

775

428

        (NT::Image(_), PT::Display) => Some(&DISPLAY_INLINE_BLOCK),

776

777

        // Media Elements

778

4

        (NT::Video, PT::Display) => Some(&DISPLAY_INLINE),

779

4

        (NT::Audio, PT::Display) => Some(&DISPLAY_INLINE),

780

4

        (NT::Canvas, PT::Display) => Some(&DISPLAY_INLINE),

781

422

        (NT::Svg, PT::Display) => Some(&DISPLAY_INLINE),

782

        // VirtualView is a block-level replaced element (like div) — must be block

783

        // so it participates in flex layout (flex-grow, etc.)

784

654

        (NT::VirtualView, PT::Display) => Some(&DISPLAY_BLOCK),

785

        // A VirtualView exists to virtualize scrollable content, so scrolling

786

        // is its DEFAULT: `auto` gets it a scroll id (wheel target) and — via

787

        // the virtual-size-aware necessity rule — a scrollbar exactly when

788

        // the published `virtual_scroll_size` overflows the viewport. A VV

789

        // that must NOT wheel-scroll (the map pans+zooms, the video widget)

790

        // opts out explicitly with `overflow: hidden`, which both already do.

791

588

        (NT::VirtualView, PT::OverflowX) => Some(&OVERFLOW_X_AUTO),

792

577

        (NT::VirtualView, PT::OverflowY) => Some(&OVERFLOW_Y_AUTO),

793

794

        // Icon Elements - inline-block so they have width/height but flow inline

795

56698

        (NT::Icon(_), PT::Display) => Some(&DISPLAY_INLINE_BLOCK),

796

797

4

        (NT::SelectOption, PT::Display) => Some(&DISPLAY_NONE),

798

4

        (NT::OptGroup, PT::Display) => Some(&DISPLAY_NONE),

799

800

        // Other Inline Elements

801

4

        (NT::Abbr, PT::Display) => Some(&DISPLAY_INLINE),

802

4

        (NT::Cite, PT::Display) => Some(&DISPLAY_INLINE),

803

4

        (NT::Del, PT::Display) => Some(&DISPLAY_INLINE),

804

4

        (NT::Ins, PT::Display) => Some(&DISPLAY_INLINE),

805

4

        (NT::Mark, PT::Display) => Some(&DISPLAY_INLINE),

806

4

        (NT::Q, PT::Display) => Some(&DISPLAY_INLINE),

807

4

        (NT::Dfn, PT::Display) => Some(&DISPLAY_INLINE),

808

4

        (NT::Var, PT::Display) => Some(&DISPLAY_INLINE),

809

4

        (NT::Time, PT::Display) => Some(&DISPLAY_INLINE),

810

4

        (NT::Data, PT::Display) => Some(&DISPLAY_INLINE),

811

4

        (NT::Wbr, PT::Display) => Some(&DISPLAY_INLINE),

812

4

        (NT::Bdi, PT::Display) => Some(&DISPLAY_INLINE),

813

4

        (NT::Bdo, PT::Display) => Some(&DISPLAY_INLINE),

814

4

        (NT::Rp, PT::Display) => Some(&DISPLAY_INLINE),

815

4

        (NT::Rt, PT::Display) => Some(&DISPLAY_INLINE),

816

4

        (NT::Rtc, PT::Display) => Some(&DISPLAY_INLINE),

817

4

        (NT::Ruby, PT::Display) => Some(&DISPLAY_INLINE),

818

819

        // Block Container Elements

820

        // Per CSS Fragmentation Level 3: figures should avoid page breaks inside

821

4

        (NT::FieldSet, PT::Display) => Some(&DISPLAY_BLOCK),

822

4

        (NT::Figure, PT::Display) => Some(&DISPLAY_BLOCK),

823

3

        (NT::Figure, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

824

4

        (NT::FigCaption, PT::Display) => Some(&DISPLAY_BLOCK),

825

3

        (NT::FigCaption, PT::BreakInside) => Some(&BREAK_INSIDE_AVOID),

826

4

        (NT::Details, PT::Display) => Some(&DISPLAY_BLOCK),

827

4

        (NT::Summary, PT::Display) => Some(&DISPLAY_BLOCK),

828

4

        (NT::Dialog, PT::Display) => Some(&DISPLAY_BLOCK),

829

830

        // Table Caption

831

5

        (NT::Caption, PT::Display) => Some(&DISPLAY_TABLE_CAPTION),

832

5

        (NT::ColGroup, PT::Display) => Some(&DISPLAY_TABLE_COLUMN_GROUP),

833

5

        (NT::Col, PT::Display) => Some(&DISPLAY_TABLE_COLUMN),

834

835

        // Legacy/Deprecated Elements

836

4

        (NT::Menu, PT::Display) => Some(&DISPLAY_BLOCK),

837

4

        (NT::Dir, PT::Display) => Some(&DISPLAY_BLOCK),

838

839

        // Html (root) Element

840

//

841

        // In browsers, the viewport itself provides scrolling when <html> overflows.

842

        // Since Azul has no separate viewport scroll mechanism, we set `height: 100%`

843

        // on the <html> element so it fills the Initial Containing Block (the viewport).

844

        // This constrains child elements like <body> to the viewport height, enabling

845

        // overflow:scroll on <body> to create scrollable content areas.

846

//

847

        // Without this, <html> has height:auto and grows to fit all content,

848

        // making container_size == content_size, which results in a useless 100% scrollbar.

849

7317

        (NT::Html, PT::Display) => Some(&DISPLAY_BLOCK),

850

        // ⚠ DIAG (2026-06-02, REVERT): the lifted get_ua_property jump table mis-dispatches

851

        // (Text/Button, Height) → THIS (Html, Height) arm → children wrongly get height:100%

852

        // → fill parent (600) instead of content. Commenting it out tests whether removing the

853

        // ONLY HEIGHT_100_PERCENT producer makes the children auto-height (confirms the chain).

854

        // REAL fix = the node_type jump-table dispatch/table-mirror in the lift, not this.

855

        // (NT::Html, PT::Height) => Some(&HEIGHT_100_PERCENT),

856

857

        // Universal fallback for display property

858

        // Per CSS spec, unknown/custom elements should default to inline

859

        // Text nodes will be filtered out before this function is called

860

542330

        (_, PT::Display) => Some(&DISPLAY_INLINE),

861

862

        // No default defined for other combinations

863

73091599

        _ => None,

864

865

76473917

866

867

// ============================================================================

868

// UA Scrollbar Defaults — individual CssPropertyWithConditions

869

// ============================================================================

870

//

871

// These rules define the default scrollbar appearance per OS and theme,

872

// using the same `@os` / `@theme` condition system as author CSS.

873

// Each entry is a single CSS property (scrollbar-color or scrollbar-width)

874

// with its conditions.  Rules are evaluated first-match-wins per property type.

875

//

876

// Conceptually equivalent to:

877

//

878

//   @os macos                { scrollbar-width: thin; }

879

//   @os ios                  { scrollbar-width: thin; }

880

//   @os android              { scrollbar-width: thin; }

881

//   /* default */            { scrollbar-width: auto; }

882

//

883

//   @os macos                { -azul-scrollbar-visibility: when-scrolling; }

884

//   @os ios                  { -azul-scrollbar-visibility: when-scrolling; }

885

//   @os android              { -azul-scrollbar-visibility: when-scrolling; }

886

//   /* default */            { -azul-scrollbar-visibility: always; }

887

//

888

//   @os macos                { -azul-scrollbar-fade-delay: 500ms; }

889

//   @os ios                  { -azul-scrollbar-fade-delay: 500ms; }

890

//   @os android              { -azul-scrollbar-fade-delay: 300ms; }

891

//   /* default */            { -azul-scrollbar-fade-delay: 0; }

892

//

893

//   @os macos                { -azul-scrollbar-fade-duration: 200ms; }

894

//   @os ios                  { -azul-scrollbar-fade-duration: 200ms; }

895

//   @os android              { -azul-scrollbar-fade-duration: 150ms; }

896

//   /* default */            { -azul-scrollbar-fade-duration: 0; }

897

//

898

//   @os macos @theme dark    { scrollbar-color: rgba(180,180,180,0.78) rgba(40,40,40,0.31); }

899

//   @os macos @theme light   { scrollbar-color: rgba(80,80,80,0.78) rgba(200,200,200,0.31); }

900

//   @os windows @theme dark  { scrollbar-color: #6e6e6e #202020; }

901

//   @os windows @theme light { scrollbar-color: #828282 #f1f1f1; }

902

//   @os ios @theme dark      { scrollbar-color: rgba(255,255,255,0.4) transparent; }

903

//   @os ios @theme light     { scrollbar-color: rgba(0,0,0,0.4) transparent; }

904

//   @os android @theme dark  { scrollbar-color: rgba(255,255,255,0.3) transparent; }

905

//   @os android @theme light { scrollbar-color: rgba(0,0,0,0.3) transparent; }

906

//   @theme dark              { scrollbar-color: #646464 #2d2d2d; }

907

//   /* default */            { scrollbar-color: #c1c1c1 #f1f1f1; }

908

909

/// Helper to create a const `scrollbar-color` `CssProperty`.

910

4

const fn scrollbar_color(thumb: ColorU, track: ColorU) -> CssProperty {

911

4

    CssProperty::ScrollbarColor(CssPropertyValue::Exact(

912

4

        StyleScrollbarColor::Custom(ScrollbarColorCustom { thumb, track }),

913

4

))

914

4

915

916

/// Helper to create a const `scrollbar-width` `CssProperty`.

917

3

const fn scrollbar_width(w: LayoutScrollbarWidth) -> CssProperty {

918

3

    CssProperty::ScrollbarWidth(CssPropertyValue::Exact(w))

919

3

920

921

/// Helper to create a const `-azul-scrollbar-visibility` `CssProperty`.

922

3

const fn scrollbar_visibility(v: ScrollbarVisibilityMode) -> CssProperty {

923

3

    CssProperty::ScrollbarVisibility(CssPropertyValue::Exact(v))

924

3

925

926

/// Helper to create a const `-azul-scrollbar-fade-delay` `CssProperty`.

927

15

const fn scrollbar_fade_delay(ms: u32) -> CssProperty {

928

15

    CssProperty::ScrollbarFadeDelay(CssPropertyValue::Exact(ScrollbarFadeDelay::new(ms)))

929

15

930

931

/// Helper to create a const `-azul-scrollbar-fade-duration` `CssProperty`.

932

12

const fn scrollbar_fade_duration(ms: u32) -> CssProperty {

933

12

    CssProperty::ScrollbarFadeDuration(CssPropertyValue::Exact(ScrollbarFadeDuration::new(ms)))

934

12

935

936

/// UA scrollbar CSS properties with `@os` / `@theme` conditions.

937

///

938

/// Ordered most-specific first.  The evaluation function picks the

939

/// first matching entry for each property type (`scrollbar-color`,

940

/// `scrollbar-width`, `-azul-scrollbar-visibility`,

941

/// `-azul-scrollbar-fade-delay`, `-azul-scrollbar-fade-duration`).

942

pub(crate) static UA_SCROLLBAR_CSS: &[CssPropertyWithConditions] = &[

943

    // ── scrollbar-width per OS ──────────────────────────────────────────

944

    // macOS → thin (overlay)

945

    CssPropertyWithConditions::with_single_condition(

946

        scrollbar_width(LayoutScrollbarWidth::Thin),

947

        &[DynamicSelector::Os(OsCondition::MacOS)],

948

),

949

    // iOS → thin

950

    CssPropertyWithConditions::with_single_condition(

951

        scrollbar_width(LayoutScrollbarWidth::Thin),

952

        &[DynamicSelector::Os(OsCondition::IOS)],

953

),

954

    // Android → thin

955

    CssPropertyWithConditions::with_single_condition(

956

        scrollbar_width(LayoutScrollbarWidth::Thin),

957

        &[DynamicSelector::Os(OsCondition::Android)],

958

),

959

    // default → auto (classic)

960

    CssPropertyWithConditions::simple(

961

        scrollbar_width(LayoutScrollbarWidth::Auto),

962

),

963

964

    // ── scrollbar-visibility per OS ─────────────────────────────────────

965

    // macOS → overlay (show only when scrolling)

966

    CssPropertyWithConditions::with_single_condition(

967

        scrollbar_visibility(ScrollbarVisibilityMode::WhenScrolling),

968

        &[DynamicSelector::Os(OsCondition::MacOS)],

969

),

970

    // iOS → overlay

971

    CssPropertyWithConditions::with_single_condition(

972

        scrollbar_visibility(ScrollbarVisibilityMode::WhenScrolling),

973

        &[DynamicSelector::Os(OsCondition::IOS)],

974

),

975

    // Android → overlay

976

    CssPropertyWithConditions::with_single_condition(

977

        scrollbar_visibility(ScrollbarVisibilityMode::WhenScrolling),

978

        &[DynamicSelector::Os(OsCondition::Android)],

979

),

980

    // default → always visible (classic)

981

    CssPropertyWithConditions::simple(

982

        scrollbar_visibility(ScrollbarVisibilityMode::Always),

983

),

984

985

    // ── scrollbar-fade-delay per OS ─────────────────────────────────────

986

    CssPropertyWithConditions::with_single_condition(

987

        scrollbar_fade_delay(500),

988

        &[DynamicSelector::Os(OsCondition::MacOS)],

989

),

990

    CssPropertyWithConditions::with_single_condition(

991

        scrollbar_fade_delay(500),

992

        &[DynamicSelector::Os(OsCondition::IOS)],

993

),

994

    CssPropertyWithConditions::with_single_condition(

995

        scrollbar_fade_delay(300),

996

        &[DynamicSelector::Os(OsCondition::Android)],

997

),

998

    // default → 0 (no fade)

999

    CssPropertyWithConditions::simple(

1000

        scrollbar_fade_delay(0),

1001

),

1002

1003

    // ── scrollbar-fade-duration per OS ──────────────────────────────────

1004

    CssPropertyWithConditions::with_single_condition(

1005

        scrollbar_fade_duration(200),

1006

        &[DynamicSelector::Os(OsCondition::MacOS)],

1007

),

1008

    CssPropertyWithConditions::with_single_condition(

1009

        scrollbar_fade_duration(200),

1010

        &[DynamicSelector::Os(OsCondition::IOS)],

1011

),

1012

    CssPropertyWithConditions::with_single_condition(

1013

        scrollbar_fade_duration(150),

1014

        &[DynamicSelector::Os(OsCondition::Android)],

1015

),

1016

    // default → 0 (instant)

1017

    CssPropertyWithConditions::simple(

1018

        scrollbar_fade_duration(0),

1019

),

1020

1021

    // ── scrollbar-color per OS + theme ──────────────────────────────────

1022

    // macOS dark: light grey thumb on dark semi-transparent track

1023

    CssPropertyWithConditions::with_single_condition(

1024

        scrollbar_color(

1025

            ColorU { r: 180, g: 180, b: 180, a: 200 },

1026

            ColorU { r: 40, g: 40, b: 40, a: 80 },

1027

),

1028

        &[DynamicSelector::Os(OsCondition::MacOS), DynamicSelector::Theme(ThemeCondition::Dark)],

1029

),

1030

    // macOS light: dark grey thumb on light semi-transparent track

1031

    CssPropertyWithConditions::with_single_condition(

1032

        scrollbar_color(

1033

            ColorU { r: 80, g: 80, b: 80, a: 200 },

1034

            ColorU { r: 200, g: 200, b: 200, a: 80 },

1035

),

1036

        &[DynamicSelector::Os(OsCondition::MacOS), DynamicSelector::Theme(ThemeCondition::Light)],

1037

),

1038

    // Windows dark

1039

    CssPropertyWithConditions::with_single_condition(

1040

        scrollbar_color(

1041

            ColorU { r: 110, g: 110, b: 110, a: 255 },

1042

            ColorU { r: 32, g: 32, b: 32, a: 255 },

1043

),

1044

        &[DynamicSelector::Os(OsCondition::Windows), DynamicSelector::Theme(ThemeCondition::Dark)],

1045

),

1046

    // Windows light

1047

    CssPropertyWithConditions::with_single_condition(

1048

        scrollbar_color(

1049

            ColorU { r: 130, g: 130, b: 130, a: 255 },

1050

            ColorU { r: 241, g: 241, b: 241, a: 255 },

1051

),

1052

        &[DynamicSelector::Os(OsCondition::Windows), DynamicSelector::Theme(ThemeCondition::Light)],

1053

),

1054

    // iOS dark

1055

    CssPropertyWithConditions::with_single_condition(

1056

        scrollbar_color(

1057

            ColorU { r: 255, g: 255, b: 255, a: 100 },

1058

            ColorU::TRANSPARENT,

1059

),

1060

        &[DynamicSelector::Os(OsCondition::IOS), DynamicSelector::Theme(ThemeCondition::Dark)],

1061

),

1062

    // iOS light

1063

    CssPropertyWithConditions::with_single_condition(

1064

        scrollbar_color(

1065

            ColorU { r: 0, g: 0, b: 0, a: 100 },

1066

            ColorU::TRANSPARENT,

1067

),

1068

        &[DynamicSelector::Os(OsCondition::IOS), DynamicSelector::Theme(ThemeCondition::Light)],

1069

),

1070

    // Android dark

1071

    CssPropertyWithConditions::with_single_condition(

1072

        scrollbar_color(

1073

            ColorU { r: 255, g: 255, b: 255, a: 77 },

1074

            ColorU::TRANSPARENT,

1075

),

1076

        &[DynamicSelector::Os(OsCondition::Android), DynamicSelector::Theme(ThemeCondition::Dark)],

1077

),

1078

    // Android light

1079

    CssPropertyWithConditions::with_single_condition(

1080

        scrollbar_color(

1081

            ColorU { r: 0, g: 0, b: 0, a: 77 },

1082

            ColorU::TRANSPARENT,

1083

),

1084

        &[DynamicSelector::Os(OsCondition::Android), DynamicSelector::Theme(ThemeCondition::Light)],

1085

),

1086

    // Linux / unknown dark fallback

1087

    CssPropertyWithConditions::with_single_condition(

1088

        scrollbar_color(

1089

            ColorU { r: 100, g: 100, b: 100, a: 255 },

1090

            ColorU { r: 45, g: 45, b: 45, a: 255 },

1091

),

1092

        &[DynamicSelector::Theme(ThemeCondition::Dark)],

1093

),

1094

    // Unconditional fallback (classic light)

1095

    CssPropertyWithConditions::simple(

1096

        scrollbar_color(

1097

            ColorU { r: 193, g: 193, b: 193, a: 255 },

1098

            ColorU { r: 241, g: 241, b: 241, a: 255 },

1099

),

1100

),

1101

];

1102

1103

/// Resolved UA scrollbar defaults after evaluating conditions.

1104

///

1105

/// All fields are guaranteed to resolve because `UA_SCROLLBAR_CSS`

1106

/// contains unconditional fallback entries for every property type.

1107

#[derive(Debug, Copy, Clone)]

1108

pub struct ResolvedUaScrollbar {

1109

    pub color: StyleScrollbarColor,

1110

    pub width: LayoutScrollbarWidth,

1111

    pub visibility: ScrollbarVisibilityMode,

1112

    pub fade_delay: ScrollbarFadeDelay,

1113

    pub fade_duration: ScrollbarFadeDuration,

1114

1115

1116

/// Evaluate UA scrollbar CSS rules against a `DynamicSelectorContext`.

1117

///

1118

/// Iterates `UA_SCROLLBAR_CSS` and picks the first matching entry per

1119

/// property type.  Unconditional fallback entries in the table guarantee

1120

/// that every field resolves.

1121

811449

#[must_use] pub fn evaluate_ua_scrollbar_css(ctx: &DynamicSelectorContext) -> ResolvedUaScrollbar {

1122

811449

    let mut color: Option<StyleScrollbarColor> = None;

1123

811449

    let mut width: Option<LayoutScrollbarWidth> = None;

1124

811449

    let mut visibility: Option<ScrollbarVisibilityMode> = None;

1125

811449

    let mut fade_delay: Option<ScrollbarFadeDelay> = None;

1126

811449

    let mut fade_duration: Option<ScrollbarFadeDuration> = None;

1127

1128

21097381

    for prop in UA_SCROLLBAR_CSS {

1129

21097381

        if !prop.matches(ctx) {

1130

17039884

            continue;

1131

4057497

1132

811512

        match &prop.property {

1133

811449

            CssProperty::ScrollbarColor(CssPropertyValue::Exact(c)) => {

1134

811449

                if color.is_none() {

1135

811449

                    color = Some(*c);

1136

811449

1137

1138

811512

            CssProperty::ScrollbarWidth(CssPropertyValue::Exact(w)) => {

1139

811512

                if width.is_none() {

1140

811449

                    width = Some(*w);

1141

811449

1142

1143

811512

            CssProperty::ScrollbarVisibility(CssPropertyValue::Exact(v)) => {

1144

811512

                if visibility.is_none() {

1145

811449

                    visibility = Some(*v);

1146

811449

1147

1148

811512

            CssProperty::ScrollbarFadeDelay(CssPropertyValue::Exact(d)) => {

1149

811512

                if fade_delay.is_none() {

1150

811449

                    fade_delay = Some(*d);

1151

811449

1152

1153

811512

            CssProperty::ScrollbarFadeDuration(CssPropertyValue::Exact(d)) => {

1154

811512

                if fade_duration.is_none() {

1155

811449

                    fade_duration = Some(*d);

1156

811449

1157

1158

            _ => {}

1159

1160

4057497

        if color.is_some() && width.is_some() && visibility.is_some()

1161

811449

            && fade_delay.is_some() && fade_duration.is_some()

1162

1163

811449

            break;

1164

3246048

1165

1166

1167

    // Unconditional `simple` entries in UA_SCROLLBAR_CSS guarantee all

1168

    // fields resolve; these defaults match those entries as a safety net.

1169

811449

    ResolvedUaScrollbar {

1170

811449

        color: color.unwrap_or(StyleScrollbarColor::Custom(ScrollbarColorCustom {

1171

811449

            thumb: ColorU { r: 193, g: 193, b: 193, a: 255 },

1172

811449

            track: ColorU { r: 241, g: 241, b: 241, a: 255 },

1173

811449

        })),

1174

811449

        width: width.unwrap_or(LayoutScrollbarWidth::Auto),

1175

811449

        visibility: visibility.unwrap_or(ScrollbarVisibilityMode::Always),

1176

811449

        fade_delay: fade_delay.unwrap_or(ScrollbarFadeDelay { ms: 0 }),

1177

811449

        fade_duration: fade_duration.unwrap_or(ScrollbarFadeDuration { ms: 0 }),

1178

811449

1179

811449

1180

1181

#[cfg(test)]

1182

mod autotest_generated {

1183

    use alloc::{string::String, vec, vec::Vec};

1184

1185

    use azul_css::{corety::AzString, css::BoxOrStatic, props::basic::length::SizeMetric};

1186

1187

    use super::*;

1188

    use crate::resources::{ImageRef, RawImageFormat};

1189

1190

    // ------------------------------------------------------------------

1191

    // Constructors / helpers

1192

    // ------------------------------------------------------------------

1193

1194

    fn text_node(s: &str) -> NodeType {

1195

        NodeType::Text(BoxOrStatic::heap(AzString::from(s)))

1196

1197

1198

    /// A VirtualView is a scroll container BY DEFAULT: `overflow: auto` on

1199

    /// both axes from the UA sheet, so app CSS no longer has to opt in (the

1200

    /// virtual-size-aware necessity rule keeps bars away until the published

1201

    /// `virtual_scroll_size` actually overflows). Opt-outs stay explicit

1202

    /// (`overflow: hidden` — map/video); invisible-but-scrollable composes

1203

    /// via `scrollbar-width: none`.

1204

    #[test]

1205

    fn virtual_view_defaults_to_overflow_auto_on_both_axes() {

1206

        use azul_css::props::layout::LayoutOverflow;

1207

        for pt in [CssPropertyType::OverflowX, CssPropertyType::OverflowY] {

1208

            let got = get_ua_property(&NodeType::VirtualView, pt)

1209

                .unwrap_or_else(|| panic!("no UA default for VirtualView {pt:?}"));

1210

            let ok = matches!(

1211

                got,

1212

                CssProperty::OverflowX(CssPropertyValue::Exact(LayoutOverflow::Auto))

1213

                    | CssProperty::OverflowY(CssPropertyValue::Exact(LayoutOverflow::Auto))

1214

);

1215

            assert!(ok, "VirtualView {pt:?} UA default is not overflow:auto: {got:?}");

1216

1217

        // And the axis-correct variant is returned for each request.

1218

        assert!(matches!(

1219

            get_ua_property(&NodeType::VirtualView, CssPropertyType::OverflowX),

1220

            Some(CssProperty::OverflowX(_))

1221

));

1222

        assert!(matches!(

1223

            get_ua_property(&NodeType::VirtualView, CssPropertyType::OverflowY),

1224

            Some(CssProperty::OverflowY(_))

1225

));

1226

1227

1228

    fn icon_node(s: &str) -> NodeType {

1229

        NodeType::Icon(BoxOrStatic::heap(AzString::from(s)))

1230

1231

1232

    fn image_node() -> NodeType {

1233

        NodeType::Image(BoxOrStatic::heap(ImageRef::null_image(

1234

1,

1235

1,

1236

            RawImageFormat::RGBA8,

1237

            Vec::new(),

1238

)))

1239

1240

1241

    /// Broad (not literally exhaustive) sample of `NodeType`, covering every

1242

    /// variant that has an arm in `get_ua_property` plus a spread of variants

1243

    /// that have none, so the catch-all arms get exercised too.

1244

    fn sample_node_types() -> Vec<NodeType> {

1245

        use crate::dom::NodeType as NT;

1246

        vec![

1247

            // matched arms

1248

            NT::Html, NT::Head, NT::Body, NT::Div, NT::P, NT::Main, NT::Header,

1249

            NT::Footer, NT::Section, NT::Article, NT::Aside, NT::Nav,

1250

            NT::H1, NT::H2, NT::H3, NT::H4, NT::H5, NT::H6,

1251

            NT::Ul, NT::Ol, NT::Li, NT::Dl, NT::Dt, NT::Dd,

1252

            NT::Span, NT::A, NT::Strong, NT::Em, NT::B, NT::I, NT::U, NT::Small,

1253

            NT::Code, NT::Kbd, NT::Samp, NT::Sub, NT::Sup,

1254

            NT::Pre, NT::BlockQuote, NT::Hr,

1255

            NT::Table, NT::THead, NT::TBody, NT::TFoot, NT::Tr, NT::Th, NT::Td,

1256

            NT::Caption, NT::ColGroup, NT::Col,

1257

            NT::Form, NT::Input, NT::Button, NT::Select, NT::TextArea, NT::Label,

1258

            NT::Title, NT::Script, NT::Style, NT::Link,

1259

            NT::Br, NT::Video, NT::Audio, NT::Canvas, NT::Svg, NT::VirtualView,

1260

            NT::SelectOption, NT::OptGroup,

1261

            NT::Abbr, NT::Cite, NT::Del, NT::Ins, NT::Mark, NT::Q, NT::Dfn,

1262

            NT::Var, NT::Time, NT::Data, NT::Wbr, NT::Bdi, NT::Bdo,

1263

            NT::Rp, NT::Rt, NT::Rtc, NT::Ruby,

1264

            NT::FieldSet, NT::Figure, NT::FigCaption, NT::Details, NT::Summary,

1265

            NT::Dialog, NT::Menu, NT::Dir,

1266

            // unmatched arms (must fall through to the catch-alls)

1267

            NT::Address, NT::Legend, NT::Output, NT::Progress, NT::Meter,

1268

            NT::DataList, NT::MenuItem, NT::S, NT::Big, NT::Acronym,

1269

            NT::Object, NT::Param, NT::Embed, NT::Source, NT::Track, NT::Map,

1270

            NT::Area, NT::Meta, NT::Base, NT::Before, NT::After, NT::Marker,

1271

            NT::Placeholder, NT::SvgG, NT::SvgPath, NT::SvgRect,

1272

            NT::SvgText(AzString::from("svg-text")),

1273

            // payload-carrying variants

1274

            text_node(""),

1275

            text_node("hello"),

1276

            icon_node("home"),

1277

            image_node(),

1278

1279

1280

1281

    fn all_os() -> Vec<OsCondition> {

1282

        vec![

1283

            OsCondition::Any,

1284

            OsCondition::Apple,

1285

            OsCondition::MacOS,

1286

            OsCondition::IOS,

1287

            OsCondition::Linux,

1288

            OsCondition::Windows,

1289

            OsCondition::Android,

1290

            OsCondition::Web,

1291

1292

1293

1294

    fn all_themes() -> Vec<ThemeCondition> {

1295

        vec![

1296

            ThemeCondition::Light,

1297

            ThemeCondition::Dark,

1298

            ThemeCondition::Custom(AzString::from("neon")),

1299

            ThemeCondition::SystemPreferred,

1300

1301

1302

1303

    fn ctx(os: OsCondition, theme: ThemeCondition) -> DynamicSelectorContext {

1304

        DynamicSelectorContext {

1305

os,

1306

            theme,

1307

            ..DynamicSelectorContext::default()

1308

1309

1310

1311

    const CLASSIC_LIGHT_THUMB: ColorU = ColorU { r: 193, g: 193, b: 193, a: 255 };

1312

    const CLASSIC_LIGHT_TRACK: ColorU = ColorU { r: 241, g: 241, b: 241, a: 255 };

1313

1314

    fn custom_color(thumb: ColorU, track: ColorU) -> StyleScrollbarColor {

1315

        StyleScrollbarColor::Custom(ScrollbarColorCustom { thumb, track })

1316

1317

1318

    /// Extract the `(thumb, track)` pair, panicking if the property is not a

1319

    /// `Custom` scrollbar color.

1320

    fn unwrap_custom(c: StyleScrollbarColor) -> (ColorU, ColorU) {

1321

        match c {

1322

            StyleScrollbarColor::Custom(c) => (c.thumb, c.track),

1323

            StyleScrollbarColor::Auto => panic!("expected a Custom scrollbar color, got Auto"),

1324

1325

1326

1327

    fn display_of(nt: &NodeType) -> LayoutDisplay {

1328

        match get_ua_property(nt, CssPropertyType::Display) {

1329

            Some(CssProperty::Display(CssPropertyValue::Exact(d))) => *d,

1330

            other => panic!("{nt:?}: expected an exact display value, got {other:?}"),

1331

1332

1333

1334

    fn font_size_em(nt: &NodeType) -> f32 {

1335

        match get_ua_property(nt, CssPropertyType::FontSize) {

1336

            Some(CssProperty::FontSize(CssPropertyValue::Exact(fs))) => {

1337

                assert_eq!(fs.inner.metric, SizeMetric::Em, "{nt:?}: font-size must be em-relative");

1338

                fs.inner.number.get()

1339

1340

            other => panic!("{nt:?}: expected an exact em font-size, got {other:?}"),

1341

1342

1343

1344

    // ==================================================================

1345

    // get_ua_property — table-wide invariants

1346

    // ==================================================================

1347

1348

    /// The single most important invariant of the lookup table: the property

1349

    /// that comes back must be *the property that was asked for*. A copy-paste

1350

    /// slip in the ~200-arm table (e.g. `(H1, MarginBottom) => &MARGIN_TOP_...`)

1351

    /// would silently mis-style elements; nothing else in the codebase checks it.

1352

    #[test]

1353

    fn returned_property_always_has_the_requested_type() {

1354

        for nt in sample_node_types() {

1355

            for pt in CssPropertyType::ALL {

1356

                if let Some(prop) = get_ua_property(&nt, *pt) {

1357

                    assert_eq!(

1358

                        prop.get_type(),

1359

                        *pt,

1360

                        "get_ua_property({nt:?}, {pt:?}) returned a {:?} property",

1361

                        prop.get_type()

1362

);

1363

1364

1365

1366

1367

1368

    #[test]

1369

    fn full_cross_product_never_panics_and_is_deterministic() {

1370

        for nt in sample_node_types() {

1371

            for pt in CssPropertyType::ALL {

1372

                let a = get_ua_property(&nt, *pt);

1373

                let b = get_ua_property(&nt, *pt);

1374

                match (a, b) {

1375

                    (Some(a), Some(b)) => assert!(

1376

                        core::ptr::eq(a, b),

1377

                        "{nt:?}/{pt:?}: repeated lookups must hand back the same static"

1378

),

1379

                    (None, None) => {}

1380

                    _ => panic!("{nt:?}/{pt:?}: lookup is not deterministic"),

1381

1382

1383

1384

1385

1386

    /// Documented contract: the `(_, Display)` catch-all means *every* node type

1387

    /// resolves a display value, so layout never sees a node without one.

1388

    #[test]

1389

    fn display_resolves_for_every_node_type() {

1390

        for nt in sample_node_types() {

1391

            assert!(

1392

                get_ua_property(&nt, CssPropertyType::Display).is_some(),

1393

                "{nt:?} has no default display"

1394

);

1395

1396

1397

1398

    #[test]

1399

    fn unknown_elements_default_to_inline_display() {

1400

        // Per CSS spec, unknown/custom elements are inline.

1401

        for nt in [NodeType::Address, NodeType::Legend, NodeType::Meter, NodeType::SvgPath] {

1402

            assert_eq!(display_of(&nt), LayoutDisplay::Inline, "{nt:?}");

1403

1404

1405

1406

    /// `cursor` is deliberately defined for exactly three node types; anything

1407

    /// else must return `None` so the cursor-resolution walk can inherit.

1408

    #[test]

1409

    fn cursor_default_exists_only_for_button_textarea_and_text() {

1410

        for nt in sample_node_types() {

1411

            let has_cursor = get_ua_property(&nt, CssPropertyType::Cursor).is_some();

1412

            let expected = matches!(nt, NodeType::Button | NodeType::TextArea | NodeType::Text(_));

1413

            assert_eq!(has_cursor, expected, "{nt:?}: unexpected cursor default");

1414

1415

1416

1417

    // ==================================================================

1418

    // get_ua_property — payload-carrying node types (unicode / huge / empty)

1419

    // ==================================================================

1420

1421

    #[test]

1422

    fn text_node_defaults_are_independent_of_the_payload() {

1423

        let huge = "🦀".repeat(100_000);

1424

        let payloads: Vec<String> = vec![

1425

            String::new(),

1426

            "\0".into(),

1427

            "\u{202E}\u{200B}\u{FEFF}".into(), // RTL override, ZWSP, BOM

1428

            "مرحبا بالعالم".into(),

1429

            "🇩🇪👨‍👩‍👧‍👦".into(),

1430

            "\u{FFFD}".into(),

1431

            huge,

1432

];

1433

1434

        for p in payloads {

1435

            let nt = text_node(&p);

1436

            assert_eq!(

1437

                display_of(&nt),

1438

                LayoutDisplay::Inline,

1439

                "text node display must not depend on its content"

1440

);

1441

            assert_eq!(

1442

                get_ua_property(&nt, CssPropertyType::Cursor),

1443

                Some(&CURSOR_TEXT),

1444

                "text node cursor must not depend on its content"

1445

);

1446

            // Text nodes define no box properties of their own.

1447

            assert!(get_ua_property(&nt, CssPropertyType::Width).is_none());

1448

            assert!(get_ua_property(&nt, CssPropertyType::Height).is_none());

1449

            assert!(get_ua_property(&nt, CssPropertyType::MarginTop).is_none());

1450

1451

1452

1453

    #[test]

1454

    fn icon_and_image_nodes_are_inline_block_regardless_of_payload() {

1455

        let huge_name = "x".repeat(50_000);

1456

        let names: [&str; 4] = ["", "home", "🏠", huge_name.as_str()];

1457

        for name in names {

1458

            assert_eq!(display_of(&icon_node(name)), LayoutDisplay::InlineBlock, "icon {name:?}");

1459

1460

        assert_eq!(display_of(&image_node()), LayoutDisplay::InlineBlock);

1461

1462

1463

    // ==================================================================

1464

    // get_ua_property — specific, load-bearing defaults

1465

    // ==================================================================

1466

1467

    /// Regression guard for the 2026-06-02 DIAG revert documented in the table:

1468

    /// `(Html, Height) => HEIGHT_100_PERCENT` is commented out on purpose. If it

1469

    /// comes back without the jump-table dispatch fix, children wrongly inherit

1470

    /// `height: 100%`.

1471

    #[test]

1472

    fn html_has_no_default_height() {

1473

        assert_eq!(get_ua_property(&NodeType::Html, CssPropertyType::Display), Some(&DISPLAY_BLOCK));

1474

        assert!(

1475

            get_ua_property(&NodeType::Html, CssPropertyType::Height).is_none(),

1476

            "the (Html, Height) arm is intentionally disabled — see the DIAG note"

1477

);

1478

1479

1480

    /// `body { margin: 8px }` (Chrome UA), and crucially *no* width/height:

1481

    /// giving body a size would break percentage sizing of its children.

1482

    #[test]

1483

    fn body_has_8px_margins_and_no_intrinsic_size() {

1484

        assert_eq!(display_of(&NodeType::Body), LayoutDisplay::Block);

1485

        assert_eq!(get_ua_property(&NodeType::Body, CssPropertyType::MarginTop), Some(&MARGIN_TOP_8PX));

1486

        assert_eq!(get_ua_property(&NodeType::Body, CssPropertyType::MarginBottom), Some(&MARGIN_BOTTOM_8PX));

1487

        assert_eq!(get_ua_property(&NodeType::Body, CssPropertyType::MarginLeft), Some(&MARGIN_LEFT_8PX));

1488

        assert_eq!(get_ua_property(&NodeType::Body, CssPropertyType::MarginRight), Some(&MARGIN_RIGHT_8PX));

1489

        assert!(get_ua_property(&NodeType::Body, CssPropertyType::Width).is_none());

1490

        assert!(get_ua_property(&NodeType::Body, CssPropertyType::Height).is_none());

1491

1492

1493

    /// Block elements must have `width: auto`, not `width: 100%` — the comment in

1494

    /// the table calls this out as critical for flexbox (100% defeats flex-grow).

1495

    #[test]

1496

    fn block_elements_have_no_default_width() {

1497

        for nt in [NodeType::Div, NodeType::P, NodeType::Section, NodeType::Main, NodeType::VirtualView] {

1498

            assert_eq!(display_of(&nt), LayoutDisplay::Block, "{nt:?}");

1499

            assert!(

1500

                get_ua_property(&nt, CssPropertyType::Width).is_none(),

1501

                "{nt:?} must be width:auto so it can flex-grow"

1502

);

1503

1504

1505

1506

    #[test]

1507

    fn div_defines_only_a_display_default() {

1508

        for pt in CssPropertyType::ALL {

1509

            let got = get_ua_property(&NodeType::Div, *pt);

1510

            if *pt == CssPropertyType::Display {

1511

                assert!(got.is_some());

1512

            } else {

1513

                assert!(got.is_none(), "Div should not define a UA default for {pt:?}");

1514

1515

1516

1517

1518

    #[test]

1519

    fn metadata_elements_are_display_none() {

1520

        for nt in [NodeType::Head, NodeType::Title, NodeType::Script, NodeType::Style, NodeType::Link] {

1521

            assert_eq!(display_of(&nt), LayoutDisplay::None, "{nt:?} must not render");

1522

1523

1524

1525

    #[test]

1526

    fn heading_font_sizes_are_strictly_decreasing() {

1527

        let sizes: Vec<f32> = [NodeType::H1, NodeType::H2, NodeType::H3, NodeType::H4, NodeType::H5, NodeType::H6]

1528

            .iter()

1529

            .map(font_size_em)

1530

            .collect();

1531

1532

        // Chrome UA values — also verifies `const_em_fractional(1, 5)` really

1533

        // encodes 1.5 (and not 1.05), which the digit-count encoding makes subtle.

1534

        let expected = [2.0_f32, 1.5, 1.17, 1.0, 0.83, 0.67];

1535

        for (i, (got, want)) in sizes.iter().zip(expected.iter()).enumerate() {

1536

            assert!(

1537

                (got - want).abs() < 1e-4,

1538

                "H{} font-size: got {got}em, want {want}em",

1539

                i + 1

1540

);

1541

1542

        for w in sizes.windows(2) {

1543

            assert!(w[0] > w[1], "heading font sizes must strictly decrease, got {sizes:?}");

1544

1545

1546

1547

    #[test]

1548

    fn headings_are_bold_blocks_that_avoid_page_breaks() {

1549

        for nt in [NodeType::H1, NodeType::H2, NodeType::H3, NodeType::H4, NodeType::H5, NodeType::H6] {

1550

            assert_eq!(display_of(&nt), LayoutDisplay::Block, "{nt:?}");

1551

            assert_eq!(

1552

                get_ua_property(&nt, CssPropertyType::FontWeight),

1553

                Some(&FONT_WEIGHT_BOLD),

1554

                "{nt:?}"

1555

);

1556

            assert_eq!(

1557

                get_ua_property(&nt, CssPropertyType::BreakInside),

1558

                Some(&BREAK_INSIDE_AVOID),

1559

                "{nt:?}"

1560

);

1561

            assert_eq!(

1562

                get_ua_property(&nt, CssPropertyType::BreakAfter),

1563

                Some(&BREAK_AFTER_AVOID),

1564

                "{nt:?}"

1565

);

1566

            // Both margins must exist and be em-relative (they scale with font-size).

1567

            for pt in [CssPropertyType::MarginTop, CssPropertyType::MarginBottom] {

1568

                assert!(get_ua_property(&nt, pt).is_some(), "{nt:?} is missing {pt:?}");

1569

1570

1571

1572

1573

    /// Tables *can* break across pages; their rows/headers/footers cannot. The

1574

    /// table comments say so explicitly, so lock the asymmetry in.

1575

    #[test]

1576

    fn tables_may_break_across_pages_but_rows_may_not() {

1577

        assert!(get_ua_property(&NodeType::Table, CssPropertyType::BreakInside).is_none());

1578

        assert!(get_ua_property(&NodeType::TBody, CssPropertyType::BreakInside).is_none());

1579

        for nt in [NodeType::THead, NodeType::TFoot, NodeType::Tr] {

1580

            assert_eq!(

1581

                get_ua_property(&nt, CssPropertyType::BreakInside),

1582

                Some(&BREAK_INSIDE_AVOID),

1583

                "{nt:?}"

1584

);

1585

1586

1587

1588

    #[test]

1589

    fn table_display_types_are_not_crossed() {

1590

        assert_eq!(display_of(&NodeType::Table), LayoutDisplay::Table);

1591

        assert_eq!(display_of(&NodeType::THead), LayoutDisplay::TableHeaderGroup);

1592

        assert_eq!(display_of(&NodeType::TBody), LayoutDisplay::TableRowGroup);

1593

        assert_eq!(display_of(&NodeType::TFoot), LayoutDisplay::TableFooterGroup);

1594

        assert_eq!(display_of(&NodeType::Tr), LayoutDisplay::TableRow);

1595

        assert_eq!(display_of(&NodeType::Th), LayoutDisplay::TableCell);

1596

        assert_eq!(display_of(&NodeType::Td), LayoutDisplay::TableCell);

1597

        assert_eq!(display_of(&NodeType::Caption), LayoutDisplay::TableCaption);

1598

        assert_eq!(display_of(&NodeType::ColGroup), LayoutDisplay::TableColumnGroup);

1599

        assert_eq!(display_of(&NodeType::Col), LayoutDisplay::TableColumn);

1600

1601

1602

    #[test]

1603

    fn table_cells_have_1px_padding_on_all_four_sides() {

1604

        for nt in [NodeType::Th, NodeType::Td] {

1605

            assert_eq!(get_ua_property(&nt, CssPropertyType::PaddingTop), Some(&PADDING_TOP_1PX), "{nt:?}");

1606

            assert_eq!(get_ua_property(&nt, CssPropertyType::PaddingBottom), Some(&PADDING_BOTTOM_1PX), "{nt:?}");

1607

            assert_eq!(get_ua_property(&nt, CssPropertyType::PaddingLeft), Some(&PADDING_LEFT_1PX), "{nt:?}");

1608

            assert_eq!(get_ua_property(&nt, CssPropertyType::PaddingRight), Some(&PADDING_RIGHT_1PX), "{nt:?}");

1609

            assert_eq!(get_ua_property(&nt, CssPropertyType::VerticalAlign), Some(&VERTICAL_ALIGN_MIDDLE), "{nt:?}");

1610

1611

        // Only <th> is centered + bold.

1612

        assert_eq!(get_ua_property(&NodeType::Th, CssPropertyType::TextAlign), Some(&TEXT_ALIGN_CENTER));

1613

        assert_eq!(get_ua_property(&NodeType::Th, CssPropertyType::FontWeight), Some(&FONT_WEIGHT_BOLD));

1614

        assert!(get_ua_property(&NodeType::Td, CssPropertyType::TextAlign).is_none());

1615

        assert!(get_ua_property(&NodeType::Td, CssPropertyType::FontWeight).is_none());

1616

1617

1618

    /// A button's border is symmetric. Crossed sides (e.g. `BorderLeftWidth`

1619

    /// answered with the *top* static) would render an asymmetric button, so

1620

    /// check that each side carries the value the table promises.

1621

    #[test]

1622

    fn button_border_is_symmetric_on_all_four_sides() {

1623

        let widths = [

1624

            (CssPropertyType::BorderTopWidth, &BUTTON_BORDER_TOP_WIDTH),

1625

            (CssPropertyType::BorderBottomWidth, &BUTTON_BORDER_BOTTOM_WIDTH),

1626

            (CssPropertyType::BorderLeftWidth, &BUTTON_BORDER_LEFT_WIDTH),

1627

            (CssPropertyType::BorderRightWidth, &BUTTON_BORDER_RIGHT_WIDTH),

1628

];

1629

        for (pt, want) in widths {

1630

            assert_eq!(get_ua_property(&NodeType::Button, pt), Some(want), "{pt:?}");

1631

1632

1633

        let styles = [

1634

            (CssPropertyType::BorderTopStyle, &BUTTON_BORDER_TOP_STYLE),

1635

            (CssPropertyType::BorderBottomStyle, &BUTTON_BORDER_BOTTOM_STYLE),

1636

            (CssPropertyType::BorderLeftStyle, &BUTTON_BORDER_LEFT_STYLE),

1637

            (CssPropertyType::BorderRightStyle, &BUTTON_BORDER_RIGHT_STYLE),

1638

];

1639

        for (pt, want) in styles {

1640

            assert_eq!(get_ua_property(&NodeType::Button, pt), Some(want), "{pt:?}");

1641

1642

1643

        let colors = [

1644

            (CssPropertyType::BorderTopColor, &BUTTON_BORDER_TOP_COLOR),

1645

            (CssPropertyType::BorderBottomColor, &BUTTON_BORDER_BOTTOM_COLOR),

1646

            (CssPropertyType::BorderLeftColor, &BUTTON_BORDER_LEFT_COLOR),

1647

            (CssPropertyType::BorderRightColor, &BUTTON_BORDER_RIGHT_COLOR),

1648

];

1649

        for (pt, want) in colors {

1650

            assert_eq!(get_ua_property(&NodeType::Button, pt), Some(want), "{pt:?}");

1651

1652

1653

        assert_eq!(display_of(&NodeType::Button), LayoutDisplay::InlineBlock);

1654

        assert_eq!(get_ua_property(&NodeType::Button, CssPropertyType::Cursor), Some(&CURSOR_POINTER));

1655

1656

1657

    /// `<hr>` draws its line from the *border*, not from a height — height must

1658

    /// be exactly 0px, and the width exactly 100%.

1659

    #[test]

1660

    fn hr_line_comes_from_the_border_not_from_height() {

1661

        match get_ua_property(&NodeType::Hr, CssPropertyType::Height) {

1662

            Some(CssProperty::Height(CssPropertyValue::Exact(LayoutHeight::Px(pv)))) => {

1663

                assert_eq!(pv.metric, SizeMetric::Px);

1664

                assert!((pv.number.get() - 0.0).abs() < 1e-6, "hr height must be 0px");

1665

1666

            other => panic!("hr height: {other:?}"),

1667

1668

        match get_ua_property(&NodeType::Hr, CssPropertyType::Width) {

1669

            Some(CssProperty::Width(CssPropertyValue::Exact(LayoutWidth::Px(pv)))) => {

1670

                assert_eq!(pv.metric, SizeMetric::Percent);

1671

                assert!((pv.number.get() - 100.0).abs() < 1e-4, "hr width must be 100%");

1672

1673

            other => panic!("hr width: {other:?}"),

1674

1675

        assert_eq!(get_ua_property(&NodeType::Hr, CssPropertyType::BorderTopStyle), Some(&BORDER_TOP_STYLE_INSET));

1676

        assert_eq!(get_ua_property(&NodeType::Hr, CssPropertyType::BorderTopWidth), Some(&BORDER_TOP_WIDTH_1PX));

1677

        assert_eq!(get_ua_property(&NodeType::Hr, CssPropertyType::BorderTopColor), Some(&BORDER_TOP_COLOR_GRAY));

1678

1679

1680

    #[test]

1681

    fn list_containers_reset_the_counter_and_reserve_marker_space() {

1682

        for (nt, marker) in [

1683

            (NodeType::Ul, &LIST_STYLE_TYPE_DISC),

1684

            (NodeType::Ol, &LIST_STYLE_TYPE_DECIMAL),

1685

] {

1686

            assert_eq!(display_of(&nt), LayoutDisplay::Block, "{nt:?}");

1687

            assert_eq!(get_ua_property(&nt, CssPropertyType::ListStyleType), Some(marker), "{nt:?}");

1688

            assert_eq!(

1689

                get_ua_property(&nt, CssPropertyType::CounterReset),

1690

                Some(&COUNTER_RESET_LIST_ITEM),

1691

                "{nt:?} must reset the list-item counter"

1692

);

1693

            assert_eq!(

1694

                get_ua_property(&nt, CssPropertyType::PaddingLeft),

1695

                Some(&PADDING_INLINE_START_40PX),

1696

                "{nt:?}"

1697

);

1698

1699

        assert_eq!(display_of(&NodeType::Li), LayoutDisplay::ListItem);

1700

1701

1702

    #[test]

1703

    fn inline_emphasis_and_link_defaults() {

1704

        assert_eq!(get_ua_property(&NodeType::A, CssPropertyType::TextDecoration), Some(&TEXT_DECORATION_UNDERLINE));

1705

        assert_eq!(get_ua_property(&NodeType::U, CssPropertyType::TextDecoration), Some(&TEXT_DECORATION_UNDERLINE));

1706

        assert_eq!(get_ua_property(&NodeType::Strong, CssPropertyType::FontWeight), Some(&FONT_WEIGHT_BOLDER));

1707

        assert_eq!(get_ua_property(&NodeType::B, CssPropertyType::FontWeight), Some(&FONT_WEIGHT_BOLDER));

1708

        // <em>/<i> are italic via font-style, which the UA table does not define.

1709

        assert!(get_ua_property(&NodeType::Em, CssPropertyType::FontWeight).is_none());

1710

        assert!(get_ua_property(&NodeType::I, CssPropertyType::FontWeight).is_none());

1711

1712

1713

    // ==================================================================

1714

    // const scrollbar helpers — numeric round-trips / boundaries

1715

    // ==================================================================

1716

1717

    #[test]

1718

    fn scrollbar_fade_delay_round_trips_every_boundary() {

1719

        for ms in [0_u32, 1, 2, 299, 300, 500, u32::from(u16::MAX), i32::MAX as u32, u32::MAX - 1, u32::MAX] {

1720

            match scrollbar_fade_delay(ms) {

1721

                CssProperty::ScrollbarFadeDelay(CssPropertyValue::Exact(d)) => {

1722

                    assert_eq!(d.ms, ms, "fade-delay must round-trip losslessly");

1723

1724

                other => panic!("scrollbar_fade_delay({ms}) built a {other:?}"),

1725

1726

1727

1728

1729

    #[test]

1730

    fn scrollbar_fade_duration_round_trips_every_boundary() {

1731

        for ms in [0_u32, 1, 150, 200, u32::from(u16::MAX), i32::MAX as u32, u32::MAX - 1, u32::MAX] {

1732

            match scrollbar_fade_duration(ms) {

1733

                CssProperty::ScrollbarFadeDuration(CssPropertyValue::Exact(d)) => {

1734

                    assert_eq!(d.ms, ms, "fade-duration must round-trip losslessly");

1735

1736

                other => panic!("scrollbar_fade_duration({ms}) built a {other:?}"),

1737

1738

1739

1740

1741

    /// `u32::MAX` in a `const` item: if either helper ever grew an arithmetic

1742

    /// conversion (ms → ns, ms → seconds), this fails to *compile* rather than

1743

    /// silently wrapping in release and panicking in debug.

1744

    #[test]

1745

    fn scrollbar_fade_helpers_are_const_evaluable_at_u32_max() {

1746

        const MAX_DELAY: CssProperty = scrollbar_fade_delay(u32::MAX);

1747

        const MAX_DURATION: CssProperty = scrollbar_fade_duration(u32::MAX);

1748

        const ZERO_DELAY: CssProperty = scrollbar_fade_delay(0);

1749

1750

        assert_eq!(MAX_DELAY, scrollbar_fade_delay(u32::MAX));

1751

        assert_eq!(MAX_DURATION, scrollbar_fade_duration(u32::MAX));

1752

        assert_eq!(ZERO_DELAY, scrollbar_fade_delay(0));

1753

1754

1755

    /// The two helpers take the same `u32` and differ only in the wrapper type —

1756

    /// exactly the shape a copy-paste bug likes. Assert they stay distinct.

1757

    #[test]

1758

    fn fade_delay_and_fade_duration_produce_distinct_property_types() {

1759

        assert_eq!(scrollbar_fade_delay(42).get_type(), CssPropertyType::ScrollbarFadeDelay);

1760

        assert_eq!(scrollbar_fade_duration(42).get_type(), CssPropertyType::ScrollbarFadeDuration);

1761

        assert_ne!(scrollbar_fade_delay(42), scrollbar_fade_duration(42));

1762

1763

1764

    /// A `0` delay means "never fades" (per the `ScrollbarFadeDelay` docs), so it

1765

    /// must be stored as a literal zero, not as a sentinel.

1766

    #[test]

1767

    fn zero_fade_delay_and_duration_are_literal_zero() {

1768

        assert_eq!(

1769

            scrollbar_fade_delay(0),

1770

            CssProperty::ScrollbarFadeDelay(CssPropertyValue::Exact(ScrollbarFadeDelay::ZERO))

1771

);

1772

        assert_eq!(

1773

            scrollbar_fade_duration(0),

1774

            CssProperty::ScrollbarFadeDuration(CssPropertyValue::Exact(ScrollbarFadeDuration::ZERO))

1775

);

1776

1777

1778

    #[test]

1779

    fn scrollbar_color_never_swaps_thumb_and_track() {

1780

        let cases = [

1781

            (ColorU { r: 1, g: 2, b: 3, a: 4 }, ColorU { r: 5, g: 6, b: 7, a: 8 }),

1782

            (ColorU { r: 0, g: 0, b: 0, a: 0 }, ColorU { r: 255, g: 255, b: 255, a: 255 }),

1783

            (ColorU { r: 255, g: 255, b: 255, a: 255 }, ColorU::TRANSPARENT),

1784

            (ColorU::TRANSPARENT, ColorU::TRANSPARENT),

1785

];

1786

        for (thumb, track) in cases {

1787

            match scrollbar_color(thumb, track) {

1788

                CssProperty::ScrollbarColor(CssPropertyValue::Exact(StyleScrollbarColor::Custom(c))) => {

1789

                    assert_eq!(c.thumb, thumb, "thumb was not preserved");

1790

                    assert_eq!(c.track, track, "track was not preserved (arguments swapped?)");

1791

1792

                other => panic!("scrollbar_color built a {other:?}"),

1793

1794

1795

1796

1797

    #[test]

1798

    fn scrollbar_width_and_visibility_round_trip_every_variant() {

1799

        for w in [LayoutScrollbarWidth::Auto, LayoutScrollbarWidth::Thin, LayoutScrollbarWidth::None] {

1800

            match scrollbar_width(w) {

1801

                CssProperty::ScrollbarWidth(CssPropertyValue::Exact(got)) => assert_eq!(got, w),

1802

                other => panic!("scrollbar_width({w:?}) built a {other:?}"),

1803

1804

1805

        for v in [

1806

            ScrollbarVisibilityMode::Always,

1807

            ScrollbarVisibilityMode::WhenScrolling,

1808

            ScrollbarVisibilityMode::Auto,

1809

] {

1810

            match scrollbar_visibility(v) {

1811

                CssProperty::ScrollbarVisibility(CssPropertyValue::Exact(got)) => assert_eq!(got, v),

1812

                other => panic!("scrollbar_visibility({v:?}) built a {other:?}"),

1813

1814

1815

1816

1817

    // ==================================================================

1818

    // UA_SCROLLBAR_CSS — table shape invariants

1819

    // ==================================================================

1820

1821

    /// `evaluate_ua_scrollbar_css` matches on exactly five property kinds and

1822

    /// silently drops everything else via `_ => {}`. A sixth property added to

1823

    /// the table would therefore never take effect — fail loudly here instead.

1824

    #[test]

1825

    fn table_contains_only_property_kinds_the_evaluator_understands() {

1826

        let understood = [

1827

            CssPropertyType::ScrollbarColor,

1828

            CssPropertyType::ScrollbarWidth,

1829

            CssPropertyType::ScrollbarVisibility,

1830

            CssPropertyType::ScrollbarFadeDelay,

1831

            CssPropertyType::ScrollbarFadeDuration,

1832

];

1833

        for (i, entry) in UA_SCROLLBAR_CSS.iter().enumerate() {

1834

            let ty = entry.property.get_type();

1835

            assert!(

1836

                understood.contains(&ty),

1837

                "UA_SCROLLBAR_CSS[{i}] is a {ty:?}, which evaluate_ua_scrollbar_css ignores"

1838

);

1839

1840

1841

1842

    /// The evaluator only reads `CssPropertyValue::Exact`; an `Auto`/`Inherit`

1843

    /// entry would be skipped without a trace.

1844

    #[test]

1845

    fn every_table_entry_carries_an_exact_value() {

1846

        for (i, entry) in UA_SCROLLBAR_CSS.iter().enumerate() {

1847

            let is_exact = matches!(

1848

                &entry.property,

1849

                CssProperty::ScrollbarColor(CssPropertyValue::Exact(_))

1850

                    | CssProperty::ScrollbarWidth(CssPropertyValue::Exact(_))

1851

                    | CssProperty::ScrollbarVisibility(CssPropertyValue::Exact(_))

1852

                    | CssProperty::ScrollbarFadeDelay(CssPropertyValue::Exact(_))

1853

                    | CssProperty::ScrollbarFadeDuration(CssPropertyValue::Exact(_))

1854

);

1855

            assert!(is_exact, "UA_SCROLLBAR_CSS[{i}] is not an Exact value: {:?}", entry.property);

1856

1857

1858

1859

    /// The documented guarantee ("unconditional fallback entries … guarantee that

1860

    /// every field resolves") plus the ordering rule it depends on: under

1861

    /// first-match-wins, an unconditional entry that is *not* last for its

1862

    /// property type would make every rule after it dead code.

1863

    #[test]

1864

    fn each_property_type_has_exactly_one_unconditional_entry_and_it_is_last() {

1865

        for ty in [

1866

            CssPropertyType::ScrollbarColor,

1867

            CssPropertyType::ScrollbarWidth,

1868

            CssPropertyType::ScrollbarVisibility,

1869

            CssPropertyType::ScrollbarFadeDelay,

1870

            CssPropertyType::ScrollbarFadeDuration,

1871

] {

1872

            let of_type: Vec<&CssPropertyWithConditions> = UA_SCROLLBAR_CSS

1873

                .iter()

1874

                .filter(|e| e.property.get_type() == ty)

1875

                .collect();

1876

            assert!(!of_type.is_empty(), "{ty:?} has no entry at all");

1877

1878

            let unconditional: Vec<usize> = of_type

1879

                .iter()

1880

                .enumerate()

1881

                .filter(|(_, e)| e.apply_if.as_slice().is_empty())

1882

                .map(|(i, _)| i)

1883

                .collect();

1884

1885

            assert_eq!(

1886

                unconditional.len(),

1887

1,

1888

                "{ty:?} must have exactly one unconditional fallback, found {}",

1889

                unconditional.len()

1890

);

1891

            assert_eq!(

1892

                unconditional[0],

1893

                of_type.len() - 1,

1894

                "{ty:?}: the unconditional fallback must come last, otherwise the \

1895

                 {} rule(s) after it are dead under first-match-wins",

1896

                of_type.len() - 1 - unconditional[0]

1897

);

1898

1899

1900

1901

    // ==================================================================

1902

    // evaluate_ua_scrollbar_css

1903

    // ==================================================================

1904

1905

    #[test]

1906

    fn default_context_resolves_to_the_classic_light_scrollbar() {

1907

        let r = evaluate_ua_scrollbar_css(&DynamicSelectorContext::default());

1908

        assert_eq!(r.width, LayoutScrollbarWidth::Auto);

1909

        assert_eq!(r.visibility, ScrollbarVisibilityMode::Always);

1910

        assert_eq!(r.fade_delay.ms, 0);

1911

        assert_eq!(r.fade_duration.ms, 0);

1912

        assert_eq!(unwrap_custom(r.color), (CLASSIC_LIGHT_THUMB, CLASSIC_LIGHT_TRACK));

1913

1914

1915

    #[test]

1916

    fn per_os_and_theme_defaults_are_what_the_table_promises() {

1917

        let cases: Vec<(OsCondition, ThemeCondition, LayoutScrollbarWidth, ScrollbarVisibilityMode, u32, u32, StyleScrollbarColor)> = vec![

1918

1919

                OsCondition::MacOS, ThemeCondition::Dark,

1920

                LayoutScrollbarWidth::Thin, ScrollbarVisibilityMode::WhenScrolling, 500, 200,

1921

                custom_color(ColorU { r: 180, g: 180, b: 180, a: 200 }, ColorU { r: 40, g: 40, b: 40, a: 80 }),

1922

),

1923

1924

                OsCondition::MacOS, ThemeCondition::Light,

1925

                LayoutScrollbarWidth::Thin, ScrollbarVisibilityMode::WhenScrolling, 500, 200,

1926

                custom_color(ColorU { r: 80, g: 80, b: 80, a: 200 }, ColorU { r: 200, g: 200, b: 200, a: 80 }),

1927

),

1928

1929

                OsCondition::Windows, ThemeCondition::Dark,

1930

                LayoutScrollbarWidth::Auto, ScrollbarVisibilityMode::Always, 0, 0,

1931

                custom_color(ColorU { r: 110, g: 110, b: 110, a: 255 }, ColorU { r: 32, g: 32, b: 32, a: 255 }),

1932

),

1933

1934

                OsCondition::Windows, ThemeCondition::Light,

1935

                LayoutScrollbarWidth::Auto, ScrollbarVisibilityMode::Always, 0, 0,

1936

                custom_color(ColorU { r: 130, g: 130, b: 130, a: 255 }, ColorU { r: 241, g: 241, b: 241, a: 255 }),

1937

),

1938

1939

                OsCondition::IOS, ThemeCondition::Dark,

1940

                LayoutScrollbarWidth::Thin, ScrollbarVisibilityMode::WhenScrolling, 500, 200,

1941

                custom_color(ColorU { r: 255, g: 255, b: 255, a: 100 }, ColorU::TRANSPARENT),

1942

),

1943

1944

                OsCondition::IOS, ThemeCondition::Light,

1945

                LayoutScrollbarWidth::Thin, ScrollbarVisibilityMode::WhenScrolling, 500, 200,

1946

                custom_color(ColorU { r: 0, g: 0, b: 0, a: 100 }, ColorU::TRANSPARENT),

1947

),

1948

1949

                OsCondition::Android, ThemeCondition::Dark,

1950

                LayoutScrollbarWidth::Thin, ScrollbarVisibilityMode::WhenScrolling, 300, 150,

1951

                custom_color(ColorU { r: 255, g: 255, b: 255, a: 77 }, ColorU::TRANSPARENT),

1952

),

1953

1954

                OsCondition::Android, ThemeCondition::Light,

1955

                LayoutScrollbarWidth::Thin, ScrollbarVisibilityMode::WhenScrolling, 300, 150,

1956

                custom_color(ColorU { r: 0, g: 0, b: 0, a: 77 }, ColorU::TRANSPARENT),

1957

),

1958

1959

                // Linux has no OS-specific colour rule: dark falls through to the

1960

                // generic dark entry.

1961

                OsCondition::Linux, ThemeCondition::Dark,

1962

                LayoutScrollbarWidth::Auto, ScrollbarVisibilityMode::Always, 0, 0,

1963

                custom_color(ColorU { r: 100, g: 100, b: 100, a: 255 }, ColorU { r: 45, g: 45, b: 45, a: 255 }),

1964

),

1965

1966

                OsCondition::Linux, ThemeCondition::Light,

1967

                LayoutScrollbarWidth::Auto, ScrollbarVisibilityMode::Always, 0, 0,

1968

                custom_color(CLASSIC_LIGHT_THUMB, CLASSIC_LIGHT_TRACK),

1969

),

1970

1971

                OsCondition::Web, ThemeCondition::Dark,

1972

                LayoutScrollbarWidth::Auto, ScrollbarVisibilityMode::Always, 0, 0,

1973

                custom_color(ColorU { r: 100, g: 100, b: 100, a: 255 }, ColorU { r: 45, g: 45, b: 45, a: 255 }),

1974

),

1975

];

1976

1977

        for (os, theme, width, visibility, delay, duration, color) in cases {

1978

            let r = evaluate_ua_scrollbar_css(&ctx(os, theme.clone()));

1979

            assert_eq!(r.width, width, "{os:?}/{theme:?}: width");

1980

            assert_eq!(r.visibility, visibility, "{os:?}/{theme:?}: visibility");

1981

            assert_eq!(r.fade_delay.ms, delay, "{os:?}/{theme:?}: fade-delay");

1982

            assert_eq!(r.fade_duration.ms, duration, "{os:?}/{theme:?}: fade-duration");

1983

            assert_eq!(r.color, color, "{os:?}/{theme:?}: color");

1984

1985

1986

1987

    /// `match_theme` compares by equality (except when the *condition* is

1988

    /// `SystemPreferred`), so a context theme of `Custom(..)` / `SystemPreferred`

1989

    /// matches no `@theme` rule at all — every such context must still resolve a

1990

    /// colour, via the unconditional fallback.

1991

    #[test]

1992

    fn unrecognised_context_themes_fall_back_instead_of_failing() {

1993

        for theme in [ThemeCondition::Custom(AzString::from("")), ThemeCondition::Custom(AzString::from("🎨")), ThemeCondition::SystemPreferred] {

1994

            // OS-conditioned properties still apply — only the theme rules miss.

1995

            let r = evaluate_ua_scrollbar_css(&ctx(OsCondition::MacOS, theme.clone()));

1996

            assert_eq!(r.width, LayoutScrollbarWidth::Thin, "{theme:?}");

1997

            assert_eq!(r.visibility, ScrollbarVisibilityMode::WhenScrolling, "{theme:?}");

1998

            assert_eq!(

1999

                unwrap_custom(r.color),

2000

                (CLASSIC_LIGHT_THUMB, CLASSIC_LIGHT_TRACK),

2001

                "{theme:?}: must fall back to the unconditional colour"

2002

);

2003

2004

2005

2006

    /// `OsCondition::Apple` is condition-side sugar (it *matches* MacOS/IOS); as a

2007

    /// *context* value it equals neither, so an `Apple` context gets the generic

2008

    /// defaults. `DynamicSelectorContext::from_system_style` never produces it, so

2009

    /// this pins down the (slightly surprising) behaviour rather than blessing it.

2010

    #[test]

2011

    fn apple_as_a_context_os_matches_no_macos_or_ios_rule() {

2012

        let r = evaluate_ua_scrollbar_css(&ctx(OsCondition::Apple, ThemeCondition::Dark));

2013

        assert_eq!(r.width, LayoutScrollbarWidth::Auto);

2014

        assert_eq!(r.visibility, ScrollbarVisibilityMode::Always);

2015

        assert_eq!(r.fade_delay.ms, 0);

2016

        assert_eq!(r.fade_duration.ms, 0);

2017

2018

2019

    /// Overlay scrollbars are a package deal: `thin` ⇔ `when-scrolling` ⇔ a

2020

    /// non-zero fade delay ⇔ a non-zero fade duration. A per-OS rule added to one

2021

    /// group but forgotten in another would produce an overlay scrollbar that

2022

    /// never fades (or a classic one that does).

2023

    #[test]

2024

    fn overlay_scrollbar_fields_stay_consistent_across_every_os_and_theme() {

2025

        for os in all_os() {

2026

            for theme in all_themes() {

2027

                let r = evaluate_ua_scrollbar_css(&ctx(os, theme.clone()));

2028

                let thin = r.width == LayoutScrollbarWidth::Thin;

2029

                let overlay = r.visibility == ScrollbarVisibilityMode::WhenScrolling;

2030

2031

                assert_eq!(thin, overlay, "{os:?}/{theme:?}: thin/when-scrolling disagree");

2032

                assert_eq!(

2033

                    overlay,

2034

                    r.fade_delay.ms > 0,

2035

                    "{os:?}/{theme:?}: an overlay scrollbar needs a fade delay"

2036

);

2037

                assert_eq!(

2038

                    overlay,

2039

                    r.fade_duration.ms > 0,

2040

                    "{os:?}/{theme:?}: an overlay scrollbar needs a fade duration"

2041

);

2042

                // The table only ever supplies Custom colours.

2043

                assert!(

2044

                    matches!(r.color, StyleScrollbarColor::Custom(_)),

2045

                    "{os:?}/{theme:?}: colour resolved to Auto"

2046

);

2047

2048

2049

2050

2051

    /// The evaluator `break`s early once all five fields are filled. Cross-check

2052

    /// it against a straight first-match-wins scan with no early exit: the two

2053

    /// must agree for every context, or the optimisation changed the semantics.

2054

    #[test]

2055

    fn early_break_does_not_change_the_first_match_result() {

2056

        for os in all_os() {

2057

            for theme in all_themes() {

2058

                let c = ctx(os, theme.clone());

2059

                let got = evaluate_ua_scrollbar_css(&c);

2060

2061

                let mut want_color = None;

2062

                let mut want_width = None;

2063

                let mut want_vis = None;

2064

                let mut want_delay = None;

2065

                let mut want_dur = None;

2066

                for entry in UA_SCROLLBAR_CSS.iter().filter(|e| e.matches(&c)) {

2067

                    match &entry.property {

2068

                        CssProperty::ScrollbarColor(CssPropertyValue::Exact(v)) => {

2069

                            if want_color.is_none() {

2070

                                want_color = Some(*v);

2071

2072

2073

                        CssProperty::ScrollbarWidth(CssPropertyValue::Exact(v)) => {

2074

                            if want_width.is_none() {

2075

                                want_width = Some(*v);

2076

2077

2078

                        CssProperty::ScrollbarVisibility(CssPropertyValue::Exact(v)) => {

2079

                            if want_vis.is_none() {

2080

                                want_vis = Some(*v);

2081

2082

2083

                        CssProperty::ScrollbarFadeDelay(CssPropertyValue::Exact(v)) => {

2084

                            if want_delay.is_none() {

2085

                                want_delay = Some(*v);

2086

2087

2088

                        CssProperty::ScrollbarFadeDuration(CssPropertyValue::Exact(v)) => {

2089

                            if want_dur.is_none() {

2090

                                want_dur = Some(*v);

2091

2092

2093

                        _ => {}

2094

2095

2096

2097

                let label = alloc::format!("{os:?}/{theme:?}");

2098

                assert_eq!(Some(got.color), want_color, "{label}: color");

2099

                assert_eq!(Some(got.width), want_width, "{label}: width");

2100

                assert_eq!(Some(got.visibility), want_vis, "{label}: visibility");

2101

                assert_eq!(Some(got.fade_delay), want_delay, "{label}: fade-delay");

2102

                assert_eq!(Some(got.fade_duration), want_dur, "{label}: fade-duration");

2103

2104

2105

2106

2107

    /// Degenerate / hostile context values (NaN, infinities, empty and huge

2108

    /// strings) must not panic, and every field must still resolve.

2109

    #[test]

2110

    fn degenerate_context_values_do_not_panic() {

2111

        let hostile = [

2112

            (f32::NAN, f32::NAN),

2113

            (0.0, 0.0),

2114

            (-0.0, -1.0),

2115

            (f32::INFINITY, f32::NEG_INFINITY),

2116

            (f32::MAX, f32::MIN),

2117

            (f32::MIN_POSITIVE, f32::EPSILON),

2118

];

2119

2120

        for (w, h) in hostile {

2121

            let c = DynamicSelectorContext {

2122

                os: OsCondition::MacOS,

2123

                theme: ThemeCondition::Dark,

2124

                de_version: u32::MAX,

2125

                viewport_width: w,

2126

                viewport_height: h,

2127

                container_width: h,

2128

                container_height: w,

2129

                language: AzString::from(""),

2130

                ..DynamicSelectorContext::default()

2131

};

2132

            let r = evaluate_ua_scrollbar_css(&c);

2133

            // macOS/dark rules are OS+theme-only, so viewport garbage cannot

2134

            // perturb them.

2135

            assert_eq!(r.width, LayoutScrollbarWidth::Thin, "viewport {w}x{h}");

2136

            assert_eq!(r.fade_delay.ms, 500, "viewport {w}x{h}");

2137

            assert!(matches!(r.color, StyleScrollbarColor::Custom(_)), "viewport {w}x{h}");

2138

2139

2140

2141

    #[test]

2142

    fn evaluate_is_deterministic() {

2143

        for os in all_os() {

2144

            for theme in all_themes() {

2145

                let c = ctx(os, theme.clone());

2146

                let a = evaluate_ua_scrollbar_css(&c);

2147

                let b = evaluate_ua_scrollbar_css(&c);

2148

                assert_eq!(a.color, b.color, "{os:?}/{theme:?}");

2149

                assert_eq!(a.width, b.width, "{os:?}/{theme:?}");

2150

                assert_eq!(a.visibility, b.visibility, "{os:?}/{theme:?}");

2151

                assert_eq!(a.fade_delay, b.fade_delay, "{os:?}/{theme:?}");

2152

                assert_eq!(a.fade_duration, b.fade_duration, "{os:?}/{theme:?}");

2153

2154

2155

2156