Grcov report - compact

1

//! Compact layout property cache — three-tier numeric encoding

2

//!

3

//! Replaces BTreeMap-based CSS property lookups with cache-friendly arrays.

4

//!

5

//! - **Tier 1**: `Vec<u64>` — ALL 21 enum properties bitpacked (8 B/node)

6

//! - **Tier 2 hot**: `Vec<CompactNodeProps>` — layout-critical numeric dimensions (68 B/node)

7

//! - **Tier 2 cold**: `Vec<CompactNodePropsCold>` — paint-only properties (28 B/node)

8

//! - **Tier 2b**: `Vec<CompactTextProps>` — text/IFC properties (24 B/node)

9

//!

10

//! Non-compact properties (background, box-shadow, transform, etc.) are

11

//! resolved via the slow cascade path in `CssPropertyCache::get_property_slow()`.

12

13

use crate::props::basic::length::{FloatValue, SizeMetric};

14

use crate::props::basic::pixel::PixelValue;

15

use crate::props::layout::{

16

    display::LayoutDisplay,

17

    dimensions::{LayoutHeight, LayoutWidth, LayoutMaxHeight, LayoutMaxWidth, LayoutMinHeight, LayoutMinWidth},

18

    flex::{

19

        LayoutAlignContent, LayoutAlignItems, LayoutAlignSelf, LayoutFlexDirection, LayoutFlexWrap,

20

        LayoutJustifyContent,

21

},

22

    grid::{LayoutGridAutoFlow, LayoutJustifySelf, LayoutJustifyItems},

23

    overflow::LayoutOverflow,

24

    position::LayoutPosition,

25

    wrapping::{LayoutClear, LayoutWritingMode},

26

    table::StyleBorderCollapse,

27

};

28

use crate::props::layout::display::LayoutFloat;

29

use crate::props::layout::dimensions::LayoutBoxSizing;

30

use crate::props::basic::font::{StyleFontStyle, StyleFontWeight};

31

use crate::props::basic::color::ColorU;

32

use crate::props::style::{StyleTextAlign, StyleVerticalAlign, StyleVisibility, StyleWhiteSpace, StyleDirection};

33

use crate::props::style::border::BorderStyle;

34

use crate::props::property::{CssProperty, CssPropertyType};

35

use crate::css::CssPropertyValue;

36

use alloc::boxed::Box;

37

use alloc::vec::Vec;

38

39

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

40

// Sentinel Constants

41

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

42

43

/// u16 sentinel values (for resolved-px ×10 and flex ×100)

44

pub const U16_SENTINEL: u16 = 0xFFFF;

45

/// Any u16 value >= this threshold is a sentinel, not a real value

46

pub const U16_SENTINEL_THRESHOLD: u16 = 0xFFF9;

47

48

/// i16 sentinel values (for signed resolved-px ×10)

49

pub const I16_SENTINEL: i16 = 0x7FFF;       // 32767

50

pub const I16_AUTO: i16 = 0x7FFE;           // 32766

51

pub const I16_INHERIT: i16 = 0x7FFD;        // 32765

52

pub const I16_INITIAL: i16 = 0x7FFC;        // 32764

53

/// Any i16 value >= this threshold is a sentinel

54

pub const I16_SENTINEL_THRESHOLD: i16 = 0x7FFC; // 32764

55

56

/// u32 sentinel values (for dimension properties with unit info)

57

pub const U32_SENTINEL: u32 = 0xFFFFFFFF;

58

pub const U32_AUTO: u32 = 0xFFFFFFFE;

59

pub const U32_NONE: u32 = 0xFFFFFFFD;

60

pub const U32_INHERIT: u32 = 0xFFFFFFFC;

61

pub const U32_INITIAL: u32 = 0xFFFFFFFB;

62

pub const U32_MIN_CONTENT: u32 = 0xFFFFFFFA;

63

pub const U32_MAX_CONTENT: u32 = 0xFFFFFFF9;

64

/// Any u32 value >= this threshold is a sentinel

65

pub const U32_SENTINEL_THRESHOLD: u32 = 0xFFFFFFF9;

66

67

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

68

// Tier 1: u64 bitfield — ALL enum properties

69

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

70

//

71

// Bit layout (52 bits used, 12 spare):

72

//   [4:0]    display          5 bits  (22 variants)

73

//   [7:5]    position         3 bits  (5 variants)

74

//   [9:8]    float            2 bits  (3 variants)

75

//   [12:10]  overflow_x       3 bits  (5 variants)

76

//   [15:13]  overflow_y       3 bits  (5 variants)

77

//   [16]     box_sizing       1 bit   (2 variants)

78

//   [18:17]  flex_direction   2 bits  (4 variants)

79

//   [20:19]  flex_wrap        2 bits  (3 variants)

80

//   [23:21]  justify_content  3 bits  (8 variants)

81

//   [26:24]  align_items      3 bits  (5 variants)

82

//   [29:27]  align_content    3 bits  (6 variants)

83

//   [31:30]  writing_mode     2 bits  (3 variants)

84

//   [33:32]  clear            2 bits  (4 variants)

85

//   [37:34]  font_weight      4 bits  (11 variants)

86

//   [39:38]  font_style       2 bits  (3 variants)

87

//   [42:40]  text_align       3 bits  (6 variants)

88

//   [44:43]  visibility       2 bits  (3 variants)

89

//   [47:45]  white_space      3 bits  (6 variants)

90

//   [48]     direction        1 bit   (2 variants)

91

//   [51:49]  vertical_align   3 bits  (8 variants)

92

//   [52]     border_collapse  1 bit   (2 variants)

93

//   [63:53]  (spare / sentinel flags)

94

95

// Bit offsets within u64

96

pub const DISPLAY_SHIFT: u32 = 0;

97

pub const POSITION_SHIFT: u32 = 5;

98

pub const FLOAT_SHIFT: u32 = 8;

99

pub const OVERFLOW_X_SHIFT: u32 = 10;

100

pub const OVERFLOW_Y_SHIFT: u32 = 13;

101

pub const BOX_SIZING_SHIFT: u32 = 16;

102

pub const FLEX_DIRECTION_SHIFT: u32 = 17;

103

pub const FLEX_WRAP_SHIFT: u32 = 19;

104

pub const JUSTIFY_CONTENT_SHIFT: u32 = 21;

105

pub const ALIGN_ITEMS_SHIFT: u32 = 24;

106

pub const ALIGN_CONTENT_SHIFT: u32 = 27;

107

pub const WRITING_MODE_SHIFT: u32 = 30;

108

pub const CLEAR_SHIFT: u32 = 32;

109

pub const FONT_WEIGHT_SHIFT: u32 = 34;

110

pub const FONT_STYLE_SHIFT: u32 = 38;

111

pub const TEXT_ALIGN_SHIFT: u32 = 40;

112

pub const VISIBILITY_SHIFT: u32 = 43;

113

pub const WHITE_SPACE_SHIFT: u32 = 45;

114

pub const DIRECTION_SHIFT: u32 = 48;

115

pub const VERTICAL_ALIGN_SHIFT: u32 = 49;

116

pub const BORDER_COLLAPSE_SHIFT: u32 = 52;

117

118

// Bit masks

119

pub const DISPLAY_MASK: u64 = 0x1F;     // 5 bits

120

pub const POSITION_MASK: u64 = 0x07;    // 3 bits

121

pub const FLOAT_MASK: u64 = 0x03;       // 2 bits

122

pub const OVERFLOW_MASK: u64 = 0x07;    // 3 bits

123

pub const BOX_SIZING_MASK: u64 = 0x01;  // 1 bit

124

pub const FLEX_DIR_MASK: u64 = 0x03;    // 2 bits

125

pub const FLEX_WRAP_MASK: u64 = 0x03;   // 2 bits

126

pub const JUSTIFY_MASK: u64 = 0x07;     // 3 bits

127

pub const ALIGN_MASK: u64 = 0x07;       // 3 bits

128

pub const WRITING_MODE_MASK: u64 = 0x03;// 2 bits

129

pub const CLEAR_MASK: u64 = 0x03;       // 2 bits

130

pub const FONT_WEIGHT_MASK: u64 = 0x0F; // 4 bits

131

pub const FONT_STYLE_MASK: u64 = 0x03;  // 2 bits

132

pub const TEXT_ALIGN_MASK: u64 = 0x07;  // 3 bits

133

pub const VISIBILITY_MASK: u64 = 0x03;  // 2 bits

134

pub const WHITE_SPACE_MASK: u64 = 0x07; // 3 bits

135

pub const DIRECTION_MASK: u64 = 0x01;   // 1 bit

136

pub const VERTICAL_ALIGN_MASK: u64 = 0x07; // 3 bits

137

pub const BORDER_COLLAPSE_MASK: u64 = 0x01; // 1 bit

138

139

pub const ALIGN_SELF_SHIFT: u32 = 53;

140

pub const JUSTIFY_SELF_SHIFT: u32 = 56;

141

pub const GRID_AUTO_FLOW_SHIFT: u32 = 59;

142

pub const JUSTIFY_ITEMS_SHIFT: u32 = 61;

143

pub const ALIGN_SELF_MASK: u64 = 0x07;     // 3 bits

144

pub const JUSTIFY_SELF_MASK: u64 = 0x07;   // 3 bits

145

pub const GRID_AUTO_FLOW_MASK: u64 = 0x03; // 2 bits (row/col × dense)

146

pub const JUSTIFY_ITEMS_MASK: u64 = 0x03;  // 2 bits (start/center/end/stretch)

147

148

/// Special value stored in the spare bits [63:51] to indicate this node has

149

/// NO tier-1 data (i.e., all defaults). 0 is a valid all-defaults encoding,

150

/// so we use bit 63 as a "tier1 populated" flag. If bit 63 is 0 and all other

151

/// bits are 0, it means "all defaults" (Display::Block, Position::Static, etc.).

152

/// We set bit 63 = 1 to mark that the node HAS been populated.

153

pub const TIER1_POPULATED_BIT: u64 = 1 << 63;

154

155

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

156

// Safe from_u8 conversion functions (no transmute!)

157

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

158

159

/// Decode display from u8. **0 = Block** (most common HTML default).

160

/// Value 31 (0x1F) = sentinel: look up in slow path for uncommon values.

161

/// Returns default (Block) on invalid input.

162

#[inline(always)]

163

525622

pub fn layout_display_from_u8(v: u8) -> LayoutDisplay {

164

525622

    match v {

165

190544

        0 => LayoutDisplay::Block,        // default when bits are 0

166

222356

        1 => LayoutDisplay::Inline,

167

1751

        2 => LayoutDisplay::InlineBlock,

168

4587

        3 => LayoutDisplay::Flex,

169

36

        4 => LayoutDisplay::None,

170

1

        5 => LayoutDisplay::InlineFlex,

171

14106

        6 => LayoutDisplay::Table,

172

1

        7 => LayoutDisplay::InlineTable,

173

1

        8 => LayoutDisplay::TableRowGroup,

174

1

        9 => LayoutDisplay::TableHeaderGroup,

175

1

        10 => LayoutDisplay::TableFooterGroup,

176

18726

        11 => LayoutDisplay::TableRow,

177

1

        12 => LayoutDisplay::TableColumnGroup,

178

1

        13 => LayoutDisplay::TableColumn,

179

73501

        14 => LayoutDisplay::TableCell,

180

1

        15 => LayoutDisplay::TableCaption,

181

1

        16 => LayoutDisplay::FlowRoot,

182

1

        17 => LayoutDisplay::ListItem,

183

1

        18 => LayoutDisplay::RunIn,

184

1

        19 => LayoutDisplay::Marker,

185

1

        20 => LayoutDisplay::Grid,

186

1

        21 => LayoutDisplay::InlineGrid,

187

1

        22 => LayoutDisplay::Contents,

188

        _ => LayoutDisplay::Block, // fallback + sentinel (31)

189

190

525622

191

192

/// Encode display to u8. **0 = Block** (most common HTML default).

193

#[inline(always)]

194

47691

pub fn layout_display_to_u8(v: LayoutDisplay) -> u8 {

195

47691

    match v {

196

20721

        LayoutDisplay::Block => 0,         // 0 = default when bits unset

197

19189

        LayoutDisplay::Inline => 1,

198

85

        LayoutDisplay::InlineBlock => 2,

199

452

        LayoutDisplay::Flex => 3,

200

43

        LayoutDisplay::None => 4,

201

1

        LayoutDisplay::InlineFlex => 5,

202

1387

        LayoutDisplay::Table => 6,

203

1

        LayoutDisplay::InlineTable => 7,

204

1

        LayoutDisplay::TableRowGroup => 8,

205

1

        LayoutDisplay::TableHeaderGroup => 9,

206

1

        LayoutDisplay::TableFooterGroup => 10,

207

1429

        LayoutDisplay::TableRow => 11,

208

1

        LayoutDisplay::TableColumnGroup => 12,

209

1

        LayoutDisplay::TableColumn => 13,

210

3571

        LayoutDisplay::TableCell => 14,

211

1

        LayoutDisplay::TableCaption => 15,

212

1

        LayoutDisplay::FlowRoot => 16,

213

1

        LayoutDisplay::ListItem => 17,

214

1

        LayoutDisplay::RunIn => 18,

215

1

        LayoutDisplay::Marker => 19,

216

799

        LayoutDisplay::Grid => 20,

217

1

        LayoutDisplay::InlineGrid => 21,

218

2

        LayoutDisplay::Contents => 22,

219

220

47691

221

222

#[inline(always)]

223

296494

pub fn layout_position_from_u8(v: u8) -> LayoutPosition {

224

296494

    match v {

225

295439

        0 => LayoutPosition::Static,

226

597

        1 => LayoutPosition::Relative,

227

456

        2 => LayoutPosition::Absolute,

228

1

        3 => LayoutPosition::Fixed,

229

1

        4 => LayoutPosition::Sticky,

230

        _ => LayoutPosition::Static,

231

232

296494

233

234

#[inline(always)]

235

129

pub fn layout_position_to_u8(v: LayoutPosition) -> u8 {

236

129

    match v {

237

3

        LayoutPosition::Static => 0,

238

62

        LayoutPosition::Relative => 1,

239

61

        LayoutPosition::Absolute => 2,

240

1

        LayoutPosition::Fixed => 3,

241

2

        LayoutPosition::Sticky => 4,

242

243

129

244

245

/// Decode float from u8. **0 = None** (CSS initial value).

246

#[inline(always)]

247

156946

pub fn layout_float_from_u8(v: u8) -> LayoutFloat {

248

156946

    match v {

249

150643

        0 => LayoutFloat::None,            // default when bits unset

250

4342

        1 => LayoutFloat::Left,

251

1961

        2 => LayoutFloat::Right,

252

        _ => LayoutFloat::None,

253

254

156946

255

256

/// Encode float to u8. **0 = None** (CSS initial value).

257

#[inline(always)]

258

1141

pub fn layout_float_to_u8(v: LayoutFloat) -> u8 {

259

1141

    match v {

260

45

        LayoutFloat::None => 0,

261

758

        LayoutFloat::Left => 1,

262

338

        LayoutFloat::Right => 2,

263

264

1141

265

266

/// Decode overflow from u8. **0 = Visible** (CSS initial value).

267

#[inline(always)]

268

369225

pub fn layout_overflow_from_u8(v: u8) -> LayoutOverflow {

269

369225

    match v {

270

367469

        0 => LayoutOverflow::Visible,      // default when bits unset

271

1752

        1 => LayoutOverflow::Hidden,

272

2

        2 => LayoutOverflow::Scroll,

273

1

        3 => LayoutOverflow::Auto,

274

1

        4 => LayoutOverflow::Clip,

275

        _ => LayoutOverflow::Visible,

276

277

369225

278

279

/// Encode overflow to u8. **0 = Visible** (CSS initial value).

280

#[inline(always)]

281

335

pub fn layout_overflow_to_u8(v: LayoutOverflow) -> u8 {

282

335

    match v {

283

4

        LayoutOverflow::Visible => 0,      // 0 = default when bits unset

284

326

        LayoutOverflow::Hidden => 1,

285

2

        LayoutOverflow::Scroll => 2,

286

1

        LayoutOverflow::Auto => 3,

287

2

        LayoutOverflow::Clip => 4,

288

289

335

290

291

#[inline(always)]

292

30315

pub fn layout_box_sizing_from_u8(v: u8) -> LayoutBoxSizing {

293

30315

    match v {

294

29788

        0 => LayoutBoxSizing::ContentBox,

295

527

        1 => LayoutBoxSizing::BorderBox,

296

        _ => LayoutBoxSizing::ContentBox,

297

298

30315

299

300

#[inline(always)]

301

930

pub fn layout_box_sizing_to_u8(v: LayoutBoxSizing) -> u8 {

302

930

    match v {

303

3

        LayoutBoxSizing::ContentBox => 0,

304

927

        LayoutBoxSizing::BorderBox => 1,

305

306

930

307

308

#[inline(always)]

309

987

pub fn layout_flex_direction_from_u8(v: u8) -> LayoutFlexDirection {

310

987

    match v {

311

633

        0 => LayoutFlexDirection::Row,

312

1

        1 => LayoutFlexDirection::RowReverse,

313

352

        2 => LayoutFlexDirection::Column,

314

1

        3 => LayoutFlexDirection::ColumnReverse,

315

        _ => LayoutFlexDirection::Row,

316

317

987

318

319

#[inline(always)]

320

338

pub fn layout_flex_direction_to_u8(v: LayoutFlexDirection) -> u8 {

321

338

    match v {

322

87

        LayoutFlexDirection::Row => 0,

323

1

        LayoutFlexDirection::RowReverse => 1,

324

248

        LayoutFlexDirection::Column => 2,

325

2

        LayoutFlexDirection::ColumnReverse => 3,

326

327

338

328

329

/// 0 = NoWrap (CSS initial value for flex-wrap)

330

#[inline(always)]

331

671

pub fn layout_flex_wrap_from_u8(v: u8) -> LayoutFlexWrap {

332

671

    match v {

333

668

        0 => LayoutFlexWrap::NoWrap,       // CSS initial

334

2

        1 => LayoutFlexWrap::Wrap,

335

1

        2 => LayoutFlexWrap::WrapReverse,

336

        _ => LayoutFlexWrap::NoWrap,

337

338

671

339

340

#[inline(always)]

341

43

pub fn layout_flex_wrap_to_u8(v: LayoutFlexWrap) -> u8 {

342

43

    match v {

343

3

        LayoutFlexWrap::NoWrap => 0,

344

38

        LayoutFlexWrap::Wrap => 1,

345

2

        LayoutFlexWrap::WrapReverse => 2,

346

347

43

348

349

#[inline(always)]

350

676

pub fn layout_justify_content_from_u8(v: u8) -> LayoutJustifyContent {

351

676

    match v {

352

633

        0 => LayoutJustifyContent::FlexStart,

353

1

        1 => LayoutJustifyContent::FlexEnd,

354

1

        2 => LayoutJustifyContent::Start,

355

1

        3 => LayoutJustifyContent::End,

356

36

        4 => LayoutJustifyContent::Center,

357

2

        5 => LayoutJustifyContent::SpaceBetween,

358

1

        6 => LayoutJustifyContent::SpaceAround,

359

1

        7 => LayoutJustifyContent::SpaceEvenly,

360

        _ => LayoutJustifyContent::FlexStart,

361

362

676

363

364

#[inline(always)]

365

72

pub fn layout_justify_content_to_u8(v: LayoutJustifyContent) -> u8 {

366

72

    match v {

367

3

        LayoutJustifyContent::FlexStart => 0,

368

1

        LayoutJustifyContent::FlexEnd => 1,

369

1

        LayoutJustifyContent::Start => 2,

370

1

        LayoutJustifyContent::End => 3,

371

61

        LayoutJustifyContent::Center => 4,

372

2

        LayoutJustifyContent::SpaceBetween => 5,

373

1

        LayoutJustifyContent::SpaceAround => 6,

374

2

        LayoutJustifyContent::SpaceEvenly => 7,

375

376

72

377

378

#[inline(always)]

379

673

pub fn layout_align_items_from_u8(v: u8) -> LayoutAlignItems {

380

673

    match v {

381

633

        0 => LayoutAlignItems::Stretch,

382

37

        1 => LayoutAlignItems::Center,

383

1

        2 => LayoutAlignItems::Start,

384

1

        3 => LayoutAlignItems::End,

385

1

        4 => LayoutAlignItems::Baseline,

386

        _ => LayoutAlignItems::Stretch,

387

388

673

389

390

#[inline(always)]

391

69

pub fn layout_align_items_to_u8(v: LayoutAlignItems) -> u8 {

392

69

    match v {

393

3

        LayoutAlignItems::Stretch => 0,

394

62

        LayoutAlignItems::Center => 1,

395

1

        LayoutAlignItems::Start => 2,

396

1

        LayoutAlignItems::End => 3,

397

2

        LayoutAlignItems::Baseline => 4,

398

399

69

400

401

#[inline(always)]

402

50

pub fn layout_align_self_to_u8(v: LayoutAlignSelf) -> u8 {

403

50

    match v {

404

2

        LayoutAlignSelf::Auto => 0,

405

43

        LayoutAlignSelf::Stretch => 1,

406

1

        LayoutAlignSelf::Center => 2,

407

1

        LayoutAlignSelf::Start => 3,

408

1

        LayoutAlignSelf::End => 4,

409

2

        LayoutAlignSelf::Baseline => 5,

410

411

50

412

413

#[inline(always)]

414

672

pub fn layout_align_self_from_u8(v: u8) -> LayoutAlignSelf {

415

672

    match v {

416

632

        0 => LayoutAlignSelf::Auto,

417

36

        1 => LayoutAlignSelf::Stretch,

418

1

        2 => LayoutAlignSelf::Center,

419

1

        3 => LayoutAlignSelf::Start,

420

1

        4 => LayoutAlignSelf::End,

421

1

        5 => LayoutAlignSelf::Baseline,

422

        _ => LayoutAlignSelf::Auto,

423

424

672

425

426

#[inline(always)]

427

7

pub fn layout_justify_self_to_u8(v: LayoutJustifySelf) -> u8 {

428

7

    match v {

429

2

        LayoutJustifySelf::Auto => 0,

430

1

        LayoutJustifySelf::Start => 1,

431

1

        LayoutJustifySelf::End => 2,

432

1

        LayoutJustifySelf::Center => 3,

433

2

        LayoutJustifySelf::Stretch => 4,

434

435

7

436

437

#[inline(always)]

438

671

pub fn layout_justify_self_from_u8(v: u8) -> LayoutJustifySelf {

439

671

    match v {

440

667

        0 => LayoutJustifySelf::Auto,

441

1

        1 => LayoutJustifySelf::Start,

442

1

        2 => LayoutJustifySelf::End,

443

1

        3 => LayoutJustifySelf::Center,

444

1

        4 => LayoutJustifySelf::Stretch,

445

        _ => LayoutJustifySelf::Auto,

446

447

671

448

449

// Tier1 uses 0 as the "unset" sentinel for every enum. For justify-items

450

// the CSS default is `normal` which behaves as `stretch` on grid items,

451

// so 0 must decode to Stretch (not Start). Getting this wrong leaves

452

// every unset grid container reporting justify-items: Start, which

453

// forces taffy to content-size items instead of stretching them across

454

// their column tracks — exactly the calc.c regression.

455

#[inline(always)]

456

7

pub fn layout_justify_items_to_u8(v: LayoutJustifyItems) -> u8 {

457

7

    match v {

458

3

        LayoutJustifyItems::Stretch => 0,

459

1

        LayoutJustifyItems::Start => 1,

460

1

        LayoutJustifyItems::End => 2,

461

2

        LayoutJustifyItems::Center => 3,

462

463

7

464

465

#[inline(always)]

466

671

pub fn layout_justify_items_from_u8(v: u8) -> LayoutJustifyItems {

467

671

    match v {

468

668

        0 => LayoutJustifyItems::Stretch,

469

1

        1 => LayoutJustifyItems::Start,

470

1

        2 => LayoutJustifyItems::End,

471

1

        3 => LayoutJustifyItems::Center,

472

        _ => LayoutJustifyItems::Stretch,

473

474

671

475

476

#[inline(always)]

477

6

pub fn layout_grid_auto_flow_to_u8(v: LayoutGridAutoFlow) -> u8 {

478

6

    match v {

479

2

        LayoutGridAutoFlow::Row => 0,

480

1

        LayoutGridAutoFlow::Column => 1,

481

1

        LayoutGridAutoFlow::RowDense => 2,

482

2

        LayoutGridAutoFlow::ColumnDense => 3,

483

484

6

485

486

#[inline(always)]

487

5

pub fn layout_grid_auto_flow_from_u8(v: u8) -> LayoutGridAutoFlow {

488

5

    match v {

489

2

        0 => LayoutGridAutoFlow::Row,

490

1

        1 => LayoutGridAutoFlow::Column,

491

1

        2 => LayoutGridAutoFlow::RowDense,

492

1

        3 => LayoutGridAutoFlow::ColumnDense,

493

        _ => LayoutGridAutoFlow::Row,

494

495

5

496

497

#[inline(always)]

498

674

pub fn layout_align_content_from_u8(v: u8) -> LayoutAlignContent {

499

674

    match v {

500

668

        0 => LayoutAlignContent::Stretch,

501

1

        1 => LayoutAlignContent::Center,

502

1

        2 => LayoutAlignContent::Start,

503

2

        3 => LayoutAlignContent::End,

504

1

        4 => LayoutAlignContent::SpaceBetween,

505

1

        5 => LayoutAlignContent::SpaceAround,

506

        _ => LayoutAlignContent::Stretch,

507

508

674

509

510

#[inline(always)]

511

10

pub fn layout_align_content_to_u8(v: LayoutAlignContent) -> u8 {

512

10

    match v {

513

3

        LayoutAlignContent::Stretch => 0,

514

1

        LayoutAlignContent::Center => 1,

515

1

        LayoutAlignContent::Start => 2,

516

2

        LayoutAlignContent::End => 3,

517

1

        LayoutAlignContent::SpaceBetween => 4,

518

2

        LayoutAlignContent::SpaceAround => 5,

519

520

10

521

522

#[inline(always)]

523

122611

pub fn layout_writing_mode_from_u8(v: u8) -> LayoutWritingMode {

524

122611

    match v {

525

122608

        0 => LayoutWritingMode::HorizontalTb,

526

2

        1 => LayoutWritingMode::VerticalRl,

527

1

        2 => LayoutWritingMode::VerticalLr,

528

        _ => LayoutWritingMode::HorizontalTb,

529

530

122611

531

532

#[inline(always)]

533

7

pub fn layout_writing_mode_to_u8(v: LayoutWritingMode) -> u8 {

534

7

    match v {

535

3

        LayoutWritingMode::HorizontalTb => 0,

536

2

        LayoutWritingMode::VerticalRl => 1,

537

2

        LayoutWritingMode::VerticalLr => 2,

538

539

7

540

541

#[inline(always)]

542

15722

pub fn layout_clear_from_u8(v: u8) -> LayoutClear {

543

15722

    match v {

544

15543

        0 => LayoutClear::None,

545

106

        1 => LayoutClear::Left,

546

36

        2 => LayoutClear::Right,

547

37

        3 => LayoutClear::Both,

548

        _ => LayoutClear::None,

549

550

15722

551

552

#[inline(always)]

553

218

pub fn layout_clear_to_u8(v: LayoutClear) -> u8 {

554

218

    match v {

555

3

        LayoutClear::None => 0,

556

127

        LayoutClear::Left => 1,

557

43

        LayoutClear::Right => 2,

558

45

        LayoutClear::Both => 3,

559

560

218

561

562

#[inline(always)]

563

/// 0 = Normal/400 (CSS initial value for font-weight)

564

36519

pub fn style_font_weight_from_u8(v: u8) -> StyleFontWeight {

565

36519

    match v {

566

36333

        0 => StyleFontWeight::Normal,     // CSS initial (400)

567

1

        1 => StyleFontWeight::W100,

568

1

        2 => StyleFontWeight::W200,

569

1

        3 => StyleFontWeight::W300,

570

1

        4 => StyleFontWeight::W500,

571

1

        5 => StyleFontWeight::W600,

572

177

        6 => StyleFontWeight::Bold,       // 700

573

1

        7 => StyleFontWeight::W800,

574

1

        8 => StyleFontWeight::W900,

575

1

        9 => StyleFontWeight::Lighter,

576

1

        10 => StyleFontWeight::Bolder,

577

        _ => StyleFontWeight::Normal,

578

579

36519

580

581

#[inline(always)]

582

/// 0 = Normal/400 (CSS initial value for font-weight)

583

363

pub fn style_font_weight_to_u8(v: StyleFontWeight) -> u8 {

584

363

    match v {

585

3

        StyleFontWeight::Normal => 0,     // CSS initial (400)

586

1

        StyleFontWeight::W100 => 1,

587

1

        StyleFontWeight::W200 => 2,

588

1

        StyleFontWeight::W300 => 3,

589

1

        StyleFontWeight::W500 => 4,

590

1

        StyleFontWeight::W600 => 5,

591

350

        StyleFontWeight::Bold => 6,       // 700

592

1

        StyleFontWeight::W800 => 7,

593

1

        StyleFontWeight::W900 => 8,

594

1

        StyleFontWeight::Lighter => 9,

595

2

        StyleFontWeight::Bolder => 10,

596

597

363

598

599

#[inline(always)]

600

36511

pub fn style_font_style_from_u8(v: u8) -> StyleFontStyle {

601

36511

    match v {

602

36508

        0 => StyleFontStyle::Normal,

603

2

        1 => StyleFontStyle::Italic,

604

1

        2 => StyleFontStyle::Oblique,

605

        _ => StyleFontStyle::Normal,

606

607

36511

608

609

#[inline(always)]

610

7

pub fn style_font_style_to_u8(v: StyleFontStyle) -> u8 {

611

7

    match v {

612

3

        StyleFontStyle::Normal => 0,

613

2

        StyleFontStyle::Italic => 1,

614

2

        StyleFontStyle::Oblique => 2,

615

616

7

617

618

#[inline(always)]

619

32349

pub fn style_text_align_from_u8(v: u8) -> StyleTextAlign {

620

32349

    match v {

621

32343

        0 => StyleTextAlign::Left,

622

2

        1 => StyleTextAlign::Center,

623

1

        2 => StyleTextAlign::Right,

624

1

        3 => StyleTextAlign::Justify,

625

1

        4 => StyleTextAlign::Start,

626

1

        5 => StyleTextAlign::End,

627

        _ => StyleTextAlign::Left,

628

629

32349

630

631

#[inline(always)]

632

10

pub fn style_text_align_to_u8(v: StyleTextAlign) -> u8 {

633

10

    match v {

634

3

        StyleTextAlign::Left => 0,

635

2

        StyleTextAlign::Center => 1,

636

1

        StyleTextAlign::Right => 2,

637

1

        StyleTextAlign::Justify => 3,

638

1

        StyleTextAlign::Start => 4,

639

2

        StyleTextAlign::End => 5,

640

641

10

642

643

#[inline(always)]

644

86806

pub fn style_visibility_from_u8(v: u8) -> StyleVisibility {

645

86806

    match v {

646

86803

        0 => StyleVisibility::Visible,

647

2

        1 => StyleVisibility::Hidden,

648

1

        2 => StyleVisibility::Collapse,

649

        _ => StyleVisibility::Visible,

650

651

86806

652

653

#[inline(always)]

654

25

pub fn style_visibility_to_u8(v: StyleVisibility) -> u8 {

655

25

    match v {

656

3

        StyleVisibility::Visible => 0,

657

20

        StyleVisibility::Hidden => 1,

658

2

        StyleVisibility::Collapse => 2,

659

660

25

661

662

#[inline(always)]

663

41904

pub fn style_white_space_from_u8(v: u8) -> StyleWhiteSpace {

664

41904

    match v {

665

40533

        0 => StyleWhiteSpace::Normal,

666

702

        1 => StyleWhiteSpace::Pre,

667

246

        2 => StyleWhiteSpace::Nowrap,

668

211

        3 => StyleWhiteSpace::PreWrap,

669

211

        4 => StyleWhiteSpace::PreLine,

670

1

        5 => StyleWhiteSpace::BreakSpaces,

671

        _ => StyleWhiteSpace::Normal,

672

673

41904

674

675

#[inline(always)]

676

766

pub fn style_white_space_to_u8(v: StyleWhiteSpace) -> u8 {

677

766

    match v {

678

297

        StyleWhiteSpace::Normal => 0,

679

212

        StyleWhiteSpace::Pre => 1,

680

85

        StyleWhiteSpace::Nowrap => 2,

681

85

        StyleWhiteSpace::PreWrap => 3,

682

85

        StyleWhiteSpace::PreLine => 4,

683

2

        StyleWhiteSpace::BreakSpaces => 5,

684

685

766

686

687

#[inline(always)]

688

75360

pub fn style_direction_from_u8(v: u8) -> StyleDirection {

689

75360

    match v {

690

75358

        0 => StyleDirection::Ltr,

691

2

        1 => StyleDirection::Rtl,

692

        _ => StyleDirection::Ltr,

693

694

75360

695

696

#[inline(always)]

697

6

pub fn style_direction_to_u8(v: StyleDirection) -> u8 {

698

6

    match v {

699

3

        StyleDirection::Ltr => 0,

700

3

        StyleDirection::Rtl => 1,

701

702

6

703

704

#[inline(always)]

705

11

pub fn style_vertical_align_from_u8(v: u8) -> StyleVerticalAlign {

706

11

    match v {

707

3

        0 => StyleVerticalAlign::Baseline,

708

1

        1 => StyleVerticalAlign::Top,

709

2

        2 => StyleVerticalAlign::Middle,

710

1

        3 => StyleVerticalAlign::Bottom,

711

1

        4 => StyleVerticalAlign::Sub,

712

1

        5 => StyleVerticalAlign::Superscript,

713

1

        6 => StyleVerticalAlign::TextTop,

714

1

        7 => StyleVerticalAlign::TextBottom,

715

        _ => StyleVerticalAlign::Baseline,

716

717

11

718

719

#[inline(always)]

720

4884

pub fn style_vertical_align_to_u8(v: StyleVerticalAlign) -> u8 {

721

4884

    match v {

722

3

        StyleVerticalAlign::Baseline => 0,

723

1

        StyleVerticalAlign::Top => 1,

724

4874

        StyleVerticalAlign::Middle => 2,

725

1

        StyleVerticalAlign::Bottom => 3,

726

1

        StyleVerticalAlign::Sub => 4,

727

1

        StyleVerticalAlign::Superscript => 5,

728

1

        StyleVerticalAlign::TextTop => 6,

729

2

        StyleVerticalAlign::TextBottom => 7,

730

        // Percentage/Length cannot be stored in the 3-bit compact cache field;

731

        // fall back to 0 (Baseline). Callers must use the slow cascade path

732

        // for vertical-align values with length/percentage units.

733

        StyleVerticalAlign::Percentage(_) | StyleVerticalAlign::Length(_) => 0,

734

735

4884

736

737

#[inline(always)]

738

1160

pub fn border_collapse_from_u8(v: u8) -> StyleBorderCollapse {

739

1160

    match v {

740

1158

        0 => StyleBorderCollapse::Separate,

741

2

        1 => StyleBorderCollapse::Collapse,

742

        _ => StyleBorderCollapse::Separate,

743

744

1160

745

746

#[inline(always)]

747

6

pub fn border_collapse_to_u8(v: StyleBorderCollapse) -> u8 {

748

6

    match v {

749

3

        StyleBorderCollapse::Separate => 0,

750

3

        StyleBorderCollapse::Collapse => 1,

751

752

6

753

754

#[inline(always)]

755

294840

pub fn border_style_from_u8(v: u8) -> BorderStyle {

756

294840

    match v {

757

289870

        0 => BorderStyle::None,

758

4970

        1 => BorderStyle::Solid,

759

        2 => BorderStyle::Double,

760

        3 => BorderStyle::Dotted,

761

        4 => BorderStyle::Dashed,

762

        5 => BorderStyle::Hidden,

763

        6 => BorderStyle::Groove,

764

        7 => BorderStyle::Ridge,

765

        8 => BorderStyle::Inset,

766

        9 => BorderStyle::Outset,

767

        _ => BorderStyle::None,

768

769

294840

770

771

#[inline(always)]

772

1866

pub fn border_style_to_u8(v: BorderStyle) -> u8 {

773

1866

    match v {

774

        BorderStyle::None => 0,

775

1866

        BorderStyle::Solid => 1,

776

        BorderStyle::Double => 2,

777

        BorderStyle::Dotted => 3,

778

        BorderStyle::Dashed => 4,

779

        BorderStyle::Hidden => 5,

780

        BorderStyle::Groove => 6,

781

        BorderStyle::Ridge => 7,

782

        BorderStyle::Inset => 8,

783

        BorderStyle::Outset => 9,

784

785

1866

786

787

/// Encode 4 border styles into a u16: [3:0]=top, [7:4]=right, [11:8]=bottom, [15:12]=left

788

#[inline]

789

pub fn encode_border_styles_packed(top: BorderStyle, right: BorderStyle, bottom: BorderStyle, left: BorderStyle) -> u16 {

790

    (border_style_to_u8(top) as u16)

791

        | ((border_style_to_u8(right) as u16) << 4)

792

        | ((border_style_to_u8(bottom) as u16) << 8)

793

        | ((border_style_to_u8(left) as u16) << 12)

794

795

796

/// Decode border-top-style from packed u16

797

#[inline(always)]

798

73710

pub fn decode_border_top_style(packed: u16) -> BorderStyle {

799

73710

    border_style_from_u8((packed & 0x0F) as u8)

800

73710

801

802

/// Decode border-right-style from packed u16

803

#[inline(always)]

804

73710

pub fn decode_border_right_style(packed: u16) -> BorderStyle {

805

73710

    border_style_from_u8(((packed >> 4) & 0x0F) as u8)

806

73710

807

808

/// Decode border-bottom-style from packed u16

809

#[inline(always)]

810

73710

pub fn decode_border_bottom_style(packed: u16) -> BorderStyle {

811

73710

    border_style_from_u8(((packed >> 8) & 0x0F) as u8)

812

73710

813

814

/// Decode border-left-style from packed u16

815

#[inline(always)]

816

73710

pub fn decode_border_left_style(packed: u16) -> BorderStyle {

817

73710

    border_style_from_u8(((packed >> 12) & 0x0F) as u8)

818

73710

819

820

/// Encode a ColorU as u32 (0xRRGGBBAA). Returns 0 for sentinel/unset.

821

#[inline(always)]

822

1866

pub fn encode_color_u32(c: &ColorU) -> u32 {

823

1866

    ((c.r as u32) << 24) | ((c.g as u32) << 16) | ((c.b as u32) << 8) | (c.a as u32)

824

1866

825

826

/// Decode a u32 back to ColorU. Returns `None` if sentinel (`0x00000000`).

827

///

828

/// **Limitation:** `rgba(0,0,0,0)` (fully transparent black) also encodes as

829

/// `0x00000000` and will be decoded as `None` (unset). This is acceptable

830

/// because fully transparent black is visually indistinguishable from unset.

831

#[inline(always)]

832

pub fn decode_color_u32(v: u32) -> Option<ColorU> {

833

    if v == 0 { return None; }

834

    Some(ColorU {

835

        r: ((v >> 24) & 0xFF) as u8,

836

        g: ((v >> 16) & 0xFF) as u8,

837

        b: ((v >> 8) & 0xFF) as u8,

838

        a: (v & 0xFF) as u8,

839

})

840

841

842

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

843

// Tier 1: Encode / Decode

844

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

845

846

/// Pack all 21 enum properties into a single u64.

847

#[inline]

848

2

pub fn encode_tier1(

849

2

    display: LayoutDisplay,

850

2

    position: LayoutPosition,

851

2

    float: LayoutFloat,

852

2

    overflow_x: LayoutOverflow,

853

2

    overflow_y: LayoutOverflow,

854

2

    box_sizing: LayoutBoxSizing,

855

2

    flex_direction: LayoutFlexDirection,

856

2

    flex_wrap: LayoutFlexWrap,

857

2

    justify_content: LayoutJustifyContent,

858

2

    align_items: LayoutAlignItems,

859

2

    align_content: LayoutAlignContent,

860

2

    writing_mode: LayoutWritingMode,

861

2

    clear: LayoutClear,

862

2

    font_weight: StyleFontWeight,

863

2

    font_style: StyleFontStyle,

864

2

    text_align: StyleTextAlign,

865

2

    visibility: StyleVisibility,

866

2

    white_space: StyleWhiteSpace,

867

2

    direction: StyleDirection,

868

2

    vertical_align: StyleVerticalAlign,

869

2

    border_collapse: StyleBorderCollapse,

870

2

) -> u64 {

871

2

    let mut v: u64 = TIER1_POPULATED_BIT;

872

2

    v |= (layout_display_to_u8(display) as u64) << DISPLAY_SHIFT;

873

2

    v |= (layout_position_to_u8(position) as u64) << POSITION_SHIFT;

874

2

    v |= (layout_float_to_u8(float) as u64) << FLOAT_SHIFT;

875

2

    v |= (layout_overflow_to_u8(overflow_x) as u64) << OVERFLOW_X_SHIFT;

876

2

    v |= (layout_overflow_to_u8(overflow_y) as u64) << OVERFLOW_Y_SHIFT;

877

2

    v |= (layout_box_sizing_to_u8(box_sizing) as u64) << BOX_SIZING_SHIFT;

878

2

    v |= (layout_flex_direction_to_u8(flex_direction) as u64) << FLEX_DIRECTION_SHIFT;

879

2

    v |= (layout_flex_wrap_to_u8(flex_wrap) as u64) << FLEX_WRAP_SHIFT;

880

2

    v |= (layout_justify_content_to_u8(justify_content) as u64) << JUSTIFY_CONTENT_SHIFT;

881

2

    v |= (layout_align_items_to_u8(align_items) as u64) << ALIGN_ITEMS_SHIFT;

882

2

    v |= (layout_align_content_to_u8(align_content) as u64) << ALIGN_CONTENT_SHIFT;

883

2

    v |= (layout_writing_mode_to_u8(writing_mode) as u64) << WRITING_MODE_SHIFT;

884

2

    v |= (layout_clear_to_u8(clear) as u64) << CLEAR_SHIFT;

885

2

    v |= (style_font_weight_to_u8(font_weight) as u64) << FONT_WEIGHT_SHIFT;

886

2

    v |= (style_font_style_to_u8(font_style) as u64) << FONT_STYLE_SHIFT;

887

2

    v |= (style_text_align_to_u8(text_align) as u64) << TEXT_ALIGN_SHIFT;

888

2

    v |= (style_visibility_to_u8(visibility) as u64) << VISIBILITY_SHIFT;

889

2

    v |= (style_white_space_to_u8(white_space) as u64) << WHITE_SPACE_SHIFT;

890

2

    v |= (style_direction_to_u8(direction) as u64) << DIRECTION_SHIFT;

891

2

    v |= (style_vertical_align_to_u8(vertical_align) as u64) << VERTICAL_ALIGN_SHIFT;

892

2

    v |= (border_collapse_to_u8(border_collapse) as u64) << BORDER_COLLAPSE_SHIFT;

893

2

894

2

895

896

/// Decode individual enum properties from a Tier 1 u64.

897

/// Each function is `#[inline(always)]` for zero-cost extraction.

898

899

#[inline(always)]

900

525598

pub fn decode_display(t1: u64) -> LayoutDisplay {

901

525598

    layout_display_from_u8(((t1 >> DISPLAY_SHIFT) & DISPLAY_MASK) as u8)

902

525598

903

904

#[inline(always)]

905

296488

pub fn decode_position(t1: u64) -> LayoutPosition {

906

296488

    layout_position_from_u8(((t1 >> POSITION_SHIFT) & POSITION_MASK) as u8)

907

296488

908

909

#[inline(always)]

910

156942

pub fn decode_float(t1: u64) -> LayoutFloat {

911

156942

    layout_float_from_u8(((t1 >> FLOAT_SHIFT) & FLOAT_MASK) as u8)

912

156942

913

914

#[inline(always)]

915

178467

pub fn decode_overflow_x(t1: u64) -> LayoutOverflow {

916

178467

    layout_overflow_from_u8(((t1 >> OVERFLOW_X_SHIFT) & OVERFLOW_MASK) as u8)

917

178467

918

919

#[inline(always)]

920

190752

pub fn decode_overflow_y(t1: u64) -> LayoutOverflow {

921

190752

    layout_overflow_from_u8(((t1 >> OVERFLOW_Y_SHIFT) & OVERFLOW_MASK) as u8)

922

190752

923

924

#[inline(always)]

925

30312

pub fn decode_box_sizing(t1: u64) -> LayoutBoxSizing {

926

30312

    layout_box_sizing_from_u8(((t1 >> BOX_SIZING_SHIFT) & BOX_SIZING_MASK) as u8)

927

30312

928

929

#[inline(always)]

930

982

pub fn decode_flex_direction(t1: u64) -> LayoutFlexDirection {

931

982

    layout_flex_direction_from_u8(((t1 >> FLEX_DIRECTION_SHIFT) & FLEX_DIR_MASK) as u8)

932

982

933

934

#[inline(always)]

935

667

pub fn decode_flex_wrap(t1: u64) -> LayoutFlexWrap {

936

667

    layout_flex_wrap_from_u8(((t1 >> FLEX_WRAP_SHIFT) & FLEX_WRAP_MASK) as u8)

937

667

938

939

#[inline(always)]

940

2

pub fn decode_justify_content(t1: u64) -> LayoutJustifyContent {

941

2

    layout_justify_content_from_u8(((t1 >> JUSTIFY_CONTENT_SHIFT) & JUSTIFY_MASK) as u8)

942

2

943

944

#[inline(always)]

945

667

pub fn decode_align_items(t1: u64) -> LayoutAlignItems {

946

667

    layout_align_items_from_u8(((t1 >> ALIGN_ITEMS_SHIFT) & ALIGN_MASK) as u8)

947

667

948

949

#[inline(always)]

950

667

pub fn decode_align_content(t1: u64) -> LayoutAlignContent {

951

667

    layout_align_content_from_u8(((t1 >> ALIGN_CONTENT_SHIFT) & ALIGN_MASK) as u8)

952

667

953

954

#[inline(always)]

955

122607

pub fn decode_writing_mode(t1: u64) -> LayoutWritingMode {

956

122607

    layout_writing_mode_from_u8(((t1 >> WRITING_MODE_SHIFT) & WRITING_MODE_MASK) as u8)

957

122607

958

959

#[inline(always)]

960

15717

pub fn decode_clear(t1: u64) -> LayoutClear {

961

15717

    layout_clear_from_u8(((t1 >> CLEAR_SHIFT) & CLEAR_MASK) as u8)

962

15717

963

964

#[inline(always)]

965

36507

pub fn decode_font_weight(t1: u64) -> StyleFontWeight {

966

36507

    style_font_weight_from_u8(((t1 >> FONT_WEIGHT_SHIFT) & FONT_WEIGHT_MASK) as u8)

967

36507

968

969

#[inline(always)]

970

36507

pub fn decode_font_style(t1: u64) -> StyleFontStyle {

971

36507

    style_font_style_from_u8(((t1 >> FONT_STYLE_SHIFT) & FONT_STYLE_MASK) as u8)

972

36507

973

974

#[inline(always)]

975

32342

pub fn decode_text_align(t1: u64) -> StyleTextAlign {

976

32342

    style_text_align_from_u8(((t1 >> TEXT_ALIGN_SHIFT) & TEXT_ALIGN_MASK) as u8)

977

32342

978

979

#[inline(always)]

980

86802

pub fn decode_visibility(t1: u64) -> StyleVisibility {

981

86802

    style_visibility_from_u8(((t1 >> VISIBILITY_SHIFT) & VISIBILITY_MASK) as u8)

982

86802

983

984

#[inline(always)]

985

41897

pub fn decode_white_space(t1: u64) -> StyleWhiteSpace {

986

41897

    style_white_space_from_u8(((t1 >> WHITE_SPACE_SHIFT) & WHITE_SPACE_MASK) as u8)

987

41897

988

989

#[inline(always)]

990

75357

pub fn decode_direction(t1: u64) -> StyleDirection {

991

75357

    style_direction_from_u8(((t1 >> DIRECTION_SHIFT) & DIRECTION_MASK) as u8)

992

75357

993

994

#[inline(always)]

995

2

pub fn decode_vertical_align(t1: u64) -> StyleVerticalAlign {

996

2

    style_vertical_align_from_u8(((t1 >> VERTICAL_ALIGN_SHIFT) & VERTICAL_ALIGN_MASK) as u8)

997

2

998

999

#[inline(always)]

1000

1157

pub fn decode_border_collapse(t1: u64) -> StyleBorderCollapse {

1001

1157

    border_collapse_from_u8(((t1 >> BORDER_COLLAPSE_SHIFT) & BORDER_COLLAPSE_MASK) as u8)

1002

1157

1003

1004

/// Returns true if the tier1 u64 was actually populated by `encode_tier1`.

1005

#[inline(always)]

1006

#[cfg(test)]

1007

3

pub fn tier1_is_populated(t1: u64) -> bool {

1008

3

    (t1 & TIER1_POPULATED_BIT) != 0

1009

3

1010

1011

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

1012

// Tier 2: CompactNodeProps — numeric dimensions (64 bytes/node)

1013

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

1014

1015

/// u32 encoding for dimension properties (width, height, min-*, max-*, flex-basis, font-size).

1016

///

1017

/// Layout: `[3:0] SizeMetric (4 bits) | [31:4] signed fixed-point ×1000 (28 bits)`

1018

///

1019

/// This matches FloatValue's internal representation (isize × 1000).

1020

/// Range: ±134,217.727 at 0.001 precision (28-bit signed = ±2^27 = ±134,217,728 / 1000).

1021

///

1022

/// Sentinel values use the top of the u32 range (0xFFFFFFF9..0xFFFFFFFF).

1023

1024

/// Encode a PixelValue into u32 with SizeMetric. Returns U32_SENTINEL if out of range.

1025

#[inline]

1026

17720

pub fn encode_pixel_value_u32(pv: &PixelValue) -> u32 {

1027

17720

    let metric = size_metric_to_u8(pv.metric) as u32;

1028

17720

    let raw = pv.number.number; // already × 1000 (FloatValue internal repr)

1029

    // 28-bit signed range: -134_217_728 ..= +134_217_727

1030

17720

    if !(-134_217_728..=134_217_727).contains(&raw) {

1031

        return U32_SENTINEL; // overflow → tier 3

1032

17720

1033

    // Pack: low 4 bits = metric, upper 28 bits = value (as unsigned offset)

1034

17720

    let value_bits = ((raw as i32) as u32) << 4;

1035

17720

    value_bits | metric

1036

17720

1037

1038

/// Decode a u32 back to PixelValue. Returns None for sentinel values.

1039

#[inline]

1040

48041

pub fn decode_pixel_value_u32(encoded: u32) -> Option<PixelValue> {

1041

48041

    if encoded >= U32_SENTINEL_THRESHOLD {

1042

117

        return None; // sentinel

1043

47924

1044

47924

    let metric = size_metric_from_u8((encoded & 0xF) as u8);

1045

    // Cast to i32 FIRST, then arithmetic right-shift to preserve sign bit

1046

47924

    let value_bits = (encoded as i32) >> 4;

1047

47924

    let raw = value_bits as isize; // × 1000

1048

47924

    Some(PixelValue {

1049

47924

        metric,

1050

47924

        number: FloatValue { number: raw },

1051

47924

})

1052

48041

1053

1054

/// Encode an i16 resolved px value (×10). Returns I16_SENTINEL if out of range.

1055

/// Range: -3276.8 ..= +3276.3 px at 0.1px precision.

1056

#[inline]

1057

141290

pub fn encode_resolved_px_i16(px: f32) -> i16 {

1058

141290

    let scaled = (px * 10.0).round() as i32;

1059

141290

    if scaled < -32768 || scaled > I16_SENTINEL_THRESHOLD as i32 - 1 {

1060

        return I16_SENTINEL; // overflow or too large → tier 3

1061

141290

1062

141290

    scaled as i16

1063

141290

1064

1065

/// Decode an i16 back to resolved px. Returns None for sentinel values.

1066

#[inline(always)]

1067

98914

pub fn decode_resolved_px_i16(v: i16) -> Option<f32> {

1068

98914

    if v >= I16_SENTINEL_THRESHOLD {

1069

32972

        return None;

1070

65942

1071

65942

    Some(v as f32 / 10.0)

1072

98914

1073

1074

/// Encode a u16 flex value (×100). Returns U16_SENTINEL if out of range.

1075

/// Range: 0.00 ..= 655.27 at 0.01 precision.

1076

#[inline]

1077

18016

pub fn encode_flex_u16(value: f32) -> u16 {

1078

18016

    let scaled = (value * 100.0).round() as i32;

1079

18016

    if scaled < 0 || scaled >= U16_SENTINEL_THRESHOLD as i32 {

1080

        return U16_SENTINEL;

1081

18016

1082

18016

    scaled as u16

1083

18016

1084

1085

/// Decode a u16 flex value back to f32. Returns None for sentinel values.

1086

#[inline(always)]

1087

1331

pub fn decode_flex_u16(v: u16) -> Option<f32> {

1088

1331

    if v >= U16_SENTINEL_THRESHOLD {

1089

        return None;

1090

1331

1091

1331

    Some(v as f32 / 100.0)

1092

1331

1093

1094

/// SizeMetric → u8 (4 bits, 12 variants)

1095

#[inline(always)]

1096

17720

pub fn size_metric_to_u8(m: SizeMetric) -> u8 {

1097

17720

    match m {

1098

13249

        SizeMetric::Px => 0,

1099

        SizeMetric::Pt => 1,

1100

282

        SizeMetric::Em => 2,

1101

        SizeMetric::Rem => 3,

1102

        SizeMetric::In => 4,

1103

        SizeMetric::Cm => 5,

1104

        SizeMetric::Mm => 6,

1105

4189

        SizeMetric::Percent => 7,

1106

        SizeMetric::Vw => 8,

1107

        SizeMetric::Vh => 9,

1108

        SizeMetric::Vmin => 10,

1109

        SizeMetric::Vmax => 11,

1110

1111

17720

1112

1113

/// u8 → SizeMetric

1114

#[inline(always)]

1115

47924

pub fn size_metric_from_u8(v: u8) -> SizeMetric {

1116

47924

    match v {

1117

39499

        0 => SizeMetric::Px,

1118

        1 => SizeMetric::Pt,

1119

282

        2 => SizeMetric::Em,

1120

        3 => SizeMetric::Rem,

1121

        4 => SizeMetric::In,

1122

        5 => SizeMetric::Cm,

1123

        6 => SizeMetric::Mm,

1124

8143

        7 => SizeMetric::Percent,

1125

        8 => SizeMetric::Vw,

1126

        9 => SizeMetric::Vh,

1127

        10 => SizeMetric::Vmin,

1128

        11 => SizeMetric::Vmax,

1129

        _ => SizeMetric::Px,

1130

1131

47924

1132

1133

/// Layout-hot compact numeric properties for a single node (68 bytes).

1134

/// Only fields accessed during the constraint-solving loop.

1135

/// All dimensions use MSB-sentinel encoding.

1136

#[derive(Debug, Copy, Clone, PartialEq)]

1137

#[repr(C)]

1138

pub struct CompactNodeProps {

1139

    // --- Dimensions needing unit (u32 MSB-sentinel) ---

1140

    pub width: u32,

1141

    pub height: u32,

1142

    pub min_width: u32,

1143

    pub max_width: u32,

1144

    pub min_height: u32,

1145

    pub max_height: u32,

1146

    pub flex_basis: u32,

1147

    pub font_size: u32,

1148

1149

    // --- Resolved px values (i16 MSB-sentinel, ×10) ---

1150

    pub padding_top: i16,

1151

    pub padding_right: i16,

1152

    pub padding_bottom: i16,

1153

    pub padding_left: i16,

1154

    pub margin_top: i16,

1155

    pub margin_right: i16,

1156

    pub margin_bottom: i16,

1157

    pub margin_left: i16,

1158

    pub border_top_width: i16,

1159

    pub border_right_width: i16,

1160

    pub border_bottom_width: i16,

1161

    pub border_left_width: i16,

1162

    pub top: i16,

1163

    pub right: i16,

1164

    pub bottom: i16,

1165

    pub left: i16,

1166

1167

    // --- Flex (u16 MSB-sentinel, ×100) ---

1168

    pub flex_grow: u16,

1169

    pub flex_shrink: u16,

1170

1171

    // --- Gap (i16 px×10, 0 = default) ---

1172

    pub row_gap: i16,

1173

    pub column_gap: i16,

1174

1175

1176

/// Paint-cold compact properties for a single node.

1177

/// Only accessed during display list generation, table layout, or text shaping.

1178

#[derive(Debug, Copy, Clone, PartialEq)]

1179

#[repr(C)]

1180

pub struct CompactNodePropsCold {

1181

    // --- Border colors (u32 RGBA as 0xRRGGBBAA, 0 = unset sentinel) ---

1182

    pub border_top_color: u32,

1183

    pub border_right_color: u32,

1184

    pub border_bottom_color: u32,

1185

    pub border_left_color: u32,

1186

1187

    // --- Border radii (i16 px × 10, I16_SENTINEL = unset/default = 0) ---

1188

    pub border_top_left_radius: i16,

1189

    pub border_top_right_radius: i16,

1190

    pub border_bottom_left_radius: i16,

1191

    pub border_bottom_right_radius: i16,

1192

1193

    // --- Other ---

1194

    pub z_index: i16,   // range ±32764, sentinel = 0x7FFF

1195

    /// Border styles packed: [3:0]=top, [7:4]=right, [11:8]=bottom, [15:12]=left

1196

    pub border_styles_packed: u16,

1197

    pub border_spacing_h: i16,

1198

    pub border_spacing_v: i16,

1199

    pub tab_size: i16,

1200

    /// Grid column start (I16_AUTO = auto, positive = line number, negative = span)

1201

    pub grid_col_start: i16,

1202

    /// Grid column end

1203

    pub grid_col_end: i16,

1204

    /// Grid row start

1205

    pub grid_row_start: i16,

1206

    /// Grid row end

1207

    pub grid_row_end: i16,

1208

1209

    // --- GPU / hot paint props ---

1210

    /// Opacity × 254 (0 = fully transparent, 254 = opaque). 255 = unset/default (= 1.0).

1211

    pub opacity: u8,

1212

    /// Bitflags for properties that are usually unset. Lets the getter

1213

    /// short-circuit without a cascade walk when the value is the default.

1214

///

1215

    /// bit 0: has_transform                (slow-walk only when set)

1216

    /// bit 1: has_transform_origin

1217

    /// bit 2: has_box_shadow

1218

    /// bit 3: has_text_decoration          (slow-walk only when set)

1219

    /// bits 4-5: scrollbar_gutter (0 = auto default, 1 = stable, 2 = both-edges, 3 = mirror)

1220

    /// bit 6: has_background                (slow-walk only when set; ≈ negative fast path)

1221

    /// bit 7: has_clip_path                 (slow-walk only when set)

1222

    pub hot_flags: u8,

1223

    /// Second byte of flags for rarely-set properties.

1224

///

1225

    /// bit 0: has_any_scrollbar_css

1226

    ///        OR of all -azul-scrollbar-* / scrollbar-color / scrollbar-width props.

1227

    ///        When clear, `get_scrollbar_style` can skip 8 cascade walks and use

1228

    ///        the UA-default result.

1229

    /// bit 1: has_counter      (counter-reset OR counter-increment)

1230

    /// bit 2: has_break        (break-before OR break-after)

1231

    /// bit 3: has_text_orientation

1232

    /// bit 4: has_text_shadow

1233

    /// bit 5: has_backdrop_filter

1234

    /// bit 6: has_filter

1235

    /// bit 7: has_mix_blend_mode

1236

    pub extra_flags: u8,

1237

1238

1239

pub const OPACITY_SENTINEL: u8 = 255;

1240

pub const HOT_FLAG_HAS_TRANSFORM: u8 = 1 << 0;

1241

pub const HOT_FLAG_HAS_TRANSFORM_ORIGIN: u8 = 1 << 1;

1242

pub const HOT_FLAG_HAS_BOX_SHADOW: u8 = 1 << 2;

1243

pub const HOT_FLAG_HAS_TEXT_DECORATION: u8 = 1 << 3;

1244

pub const HOT_FLAG_SCROLLBAR_GUTTER_SHIFT: u8 = 4;

1245

pub const HOT_FLAG_SCROLLBAR_GUTTER_MASK: u8 = 0b0011_0000;

1246

pub const HOT_FLAG_HAS_BACKGROUND: u8 = 1 << 6;

1247

pub const HOT_FLAG_HAS_CLIP_PATH: u8 = 1 << 7;

1248

pub const EXTRA_FLAG_HAS_SCROLLBAR_CSS: u8 = 1 << 0;

1249

pub const EXTRA_FLAG_HAS_COUNTER: u8 = 1 << 1;

1250

pub const EXTRA_FLAG_HAS_BREAK: u8 = 1 << 2;

1251

pub const EXTRA_FLAG_HAS_TEXT_ORIENTATION: u8 = 1 << 3;

1252

pub const EXTRA_FLAG_HAS_TEXT_SHADOW: u8 = 1 << 4;

1253

pub const EXTRA_FLAG_HAS_BACKDROP_FILTER: u8 = 1 << 5;

1254

pub const EXTRA_FLAG_HAS_FILTER: u8 = 1 << 6;

1255

pub const EXTRA_FLAG_HAS_MIX_BLEND_MODE: u8 = 1 << 7;

1256

1257

// ---- DOM-level rare text prop flags (stored on CompactLayoutCache) ----

1258

// Each bit = "some node in this DOM declared this property".

1259

// When clear, cascade walks for that prop anywhere in the DOM

1260

// necessarily return None → callers can skip the walk and use

1261

// the default value. Eliminates ~N × IFC-count walks per layout

1262

// in typical pages where these props are never declared.

1263

pub const DOM_HAS_SHAPE_INSIDE: u32 = 1 << 0;

1264

pub const DOM_HAS_SHAPE_OUTSIDE: u32 = 1 << 1;

1265

pub const DOM_HAS_TEXT_JUSTIFY: u32 = 1 << 2;

1266

pub const DOM_HAS_TEXT_INDENT: u32 = 1 << 3;

1267

pub const DOM_HAS_COLUMN_COUNT: u32 = 1 << 4;

1268

pub const DOM_HAS_COLUMN_GAP: u32 = 1 << 5;

1269

pub const DOM_HAS_INITIAL_LETTER: u32 = 1 << 6;

1270

pub const DOM_HAS_INITIAL_LETTER_ALIGN: u32 = 1 << 7;

1271

pub const DOM_HAS_LINE_CLAMP: u32 = 1 << 8;

1272

pub const DOM_HAS_HANGING_PUNCTUATION: u32 = 1 << 9;

1273

pub const DOM_HAS_TEXT_COMBINE_UPRIGHT: u32 = 1 << 10;

1274

pub const DOM_HAS_EXCLUSION_MARGIN: u32 = 1 << 11;

1275

pub const DOM_HAS_HYPHENATION_LANGUAGE: u32 = 1 << 12;

1276

pub const DOM_HAS_UNICODE_BIDI: u32 = 1 << 13;

1277

pub const DOM_HAS_TEXT_BOX_TRIM: u32 = 1 << 14;

1278

pub const DOM_HAS_HYPHENS: u32 = 1 << 15;

1279

pub const DOM_HAS_WORD_BREAK: u32 = 1 << 16;

1280

pub const DOM_HAS_OVERFLOW_WRAP: u32 = 1 << 17;

1281

pub const DOM_HAS_LINE_BREAK: u32 = 1 << 18;

1282

pub const DOM_HAS_TEXT_ALIGN_LAST: u32 = 1 << 19;

1283

pub const DOM_HAS_LINE_HEIGHT: u32 = 1 << 20;

1284

pub const DOM_HAS_COLUMN_WIDTH: u32 = 1 << 21;

1285

pub const DOM_HAS_SHAPE_MARGIN: u32 = 1 << 22;

1286

pub const SCROLLBAR_GUTTER_AUTO: u8 = 0;

1287

pub const SCROLLBAR_GUTTER_STABLE: u8 = 1;

1288

pub const SCROLLBAR_GUTTER_BOTH_EDGES: u8 = 2;

1289

pub const SCROLLBAR_GUTTER_MIRROR: u8 = 3;

1290

1291

impl Default for CompactNodeProps {

1292

17847

    fn default() -> Self {

1293

17847

        Self {

1294

17847

            // All dimensions default to Auto

1295

17847

            width: U32_AUTO,

1296

17847

            height: U32_AUTO,

1297

17847

            min_width: U32_AUTO,

1298

17847

            max_width: U32_NONE,

1299

17847

            min_height: U32_AUTO,

1300

17847

            max_height: U32_NONE,

1301

17847

            flex_basis: U32_AUTO,

1302

17847

            font_size: U32_INITIAL,

1303

17847

            // All resolved px default to 0

1304

17847

            padding_top: 0,

1305

17847

            padding_right: 0,

1306

17847

            padding_bottom: 0,

1307

17847

            padding_left: 0,

1308

17847

            margin_top: 0,

1309

17847

            margin_right: 0,

1310

17847

            margin_bottom: 0,

1311

17847

            margin_left: 0,

1312

17847

            border_top_width: 0,

1313

17847

            border_right_width: 0,

1314

17847

            border_bottom_width: 0,

1315

17847

            border_left_width: 0,

1316

17847

            top: I16_AUTO,

1317

17847

            right: I16_AUTO,

1318

17847

            bottom: I16_AUTO,

1319

17847

            left: I16_AUTO,

1320

17847

            // Flex defaults

1321

17847

            flex_grow: 0,

1322

17847

            flex_shrink: encode_flex_u16(1.0), // CSS default: flex-shrink: 1

1323

17847

1324

17847

            // Gap defaults

1325

17847

            row_gap: 0,

1326

17847

            column_gap: 0,

1327

17847

1328

17847

1329

1330

1331

impl Default for CompactNodePropsCold {

1332

17847

    fn default() -> Self {

1333

17847

        Self {

1334

17847

            // Border colors default to 0 (sentinel/unset)

1335

17847

            border_top_color: 0,

1336

17847

            border_right_color: 0,

1337

17847

            border_bottom_color: 0,

1338

17847

            border_left_color: 0,

1339

17847

            // Border radii: I16_SENTINEL means "no rounded corner" (skip slow walk)

1340

17847

            border_top_left_radius: I16_SENTINEL,

1341

17847

            border_top_right_radius: I16_SENTINEL,

1342

17847

            border_bottom_left_radius: I16_SENTINEL,

1343

17847

            border_bottom_right_radius: I16_SENTINEL,

1344

17847

            // Other

1345

17847

            z_index: I16_AUTO,

1346

17847

            border_styles_packed: 0, // all BorderStyle::None

1347

17847

            border_spacing_h: 0,

1348

17847

            border_spacing_v: 0,

1349

17847

            tab_size: I16_SENTINEL, // default is 8em, needs resolution → sentinel

1350

17847

            grid_col_start: I16_AUTO,

1351

17847

            grid_col_end: I16_AUTO,

1352

17847

            grid_row_start: I16_AUTO,

1353

17847

            grid_row_end: I16_AUTO,

1354

17847

            opacity: OPACITY_SENTINEL,

1355

17847

            hot_flags: 0,

1356

17847

            extra_flags: 0,

1357

17847

1358

17847

1359

1360

1361

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

1362

// Tier 2b: CompactTextProps — IFC/text properties (24 bytes/node)

1363

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

1364

1365

/// Compact text/IFC properties for a single node (24 bytes).

1366

#[derive(Debug, Copy, Clone, PartialEq)]

1367

#[repr(C)]

1368

pub struct CompactTextProps {

1369

    pub text_color: u32,       // RGBA as 0xRRGGBBAA (0 = transparent/unset)

1370

    pub font_family_hash: u64, // FxHash of font-family list (0 = sentinel/unset)

1371

    pub line_height: i16,      // px × 10, sentinel = I16_SENTINEL

1372

    pub letter_spacing: i16,   // px × 10

1373

    pub word_spacing: i16,     // px × 10

1374

    pub text_indent: i16,      // px × 10

1375

1376

1377

impl Default for CompactTextProps {

1378

17847

    fn default() -> Self {

1379

17847

        Self {

1380

17847

            text_color: 0,

1381

17847

            font_family_hash: 0,

1382

17847

            line_height: I16_SENTINEL, // "normal" → sentinel

1383

17847

            letter_spacing: 0,

1384

17847

            word_spacing: 0,

1385

17847

            text_indent: 0,

1386

17847

1387

17847

1388

1389

1390

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

1391

// Tier 3: Overflow map — rare/complex properties

1392

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

1393

1394

/// Overflow properties that couldn't fit in Tier 1/2 encoding.

1395

/// Contains the original `CssProperty` values for properties that:

1396

/// - Have calc() expressions

1397

/// - Exceed the numeric range of compact encoding

1398

/// - Are rare CSS properties (grid, transforms, etc.)

1399

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

1400

// CompactLayoutCache — the top-level container

1401

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

1402

1403

/// Three-tier compact layout property cache.

1404

///

1405

/// Allocated once per restyle, indexed by node index (same as NodeId).

1406

/// Provides O(1) array-indexed access to all layout properties.

1407

///

1408

/// Non-compact properties (background, box-shadow, transform, etc.) are

1409

/// resolved via the slow cascade path in `CssPropertyCache::get_property_slow()`.

1410

#[derive(Debug, Clone, PartialEq)]

1411

pub struct CompactLayoutCache {

1412

    /// Tier 1: ALL enum properties bitpacked into u64 per node (8 B/node)

1413

    pub tier1_enums: Vec<u64>,

1414

    /// Tier 2 hot: Layout-critical numeric dimensions per node (68 B/node)

1415

    pub tier2_dims: Vec<CompactNodeProps>,

1416

    /// Tier 2 cold: Paint-only properties per node (28 B/node)

1417

    pub tier2_cold: Vec<CompactNodePropsCold>,

1418

    /// Tier 2b: Text/IFC properties per node (24 B/node)

1419

    pub tier2b_text: Vec<CompactTextProps>,

1420

    /// Indices of nodes whose `font_family_hash` changed since the last frame.

1421

///

1422

    /// Enables **per-node** font dirty tracking instead of the global all-or-nothing

1423

    /// `font_stacks_hash` XOR approach. When this list is non-empty, only the

1424

    /// font chains for these specific nodes need to be re-resolved, avoiding O(N)

1425

    /// re-resolution when a single node's `font-family` changes.

1426

///

1427

    /// Populated during `build_compact_cache()` by comparing each node's

1428

    /// `font_family_hash` against `prev_font_hashes`.

1429

    pub font_dirty_nodes: Vec<usize>,

1430

    /// Previous frame's per-node `font_family_hash` values.

1431

///

1432

    /// Stored after each compact cache build so that the next build can detect

1433

    /// which specific nodes' font-family changed (rather than relying on a

1434

    /// collision-prone global XOR hash).

1435

    pub prev_font_hashes: Vec<u64>,

1436

    /// Reverse map: `font_family_hash` (u64) → actual `StyleFontFamilyVec`.

1437

///

1438

    /// Populated during `build_compact_cache()` as a byproduct of hash computation.

1439

    /// Consumers use this to look up font family names from the compact cache hash

1440

    /// without going through `get_property_slow()` (which fails for inherited values

1441

    /// on text nodes).

1442

    pub font_hash_to_families: alloc::collections::BTreeMap<u64, crate::props::basic::font::StyleFontFamilyVec>,

1443

    /// Bitfield tracking which rare text props are declared *anywhere* in the DOM.

1444

    /// Built once during `build_compact_cache_with_inheritance`. When a bit is

1445

    /// clear, callers (e.g. `translate_to_text3_constraints`) can skip the

1446

    /// cascade walk for that property — its slow path would always return

1447

    /// `None` and fall back to the default. See `DOM_HAS_*` constants.

1448

    pub dom_declared_flags: u32,

1449

1450

1451

impl CompactLayoutCache {

1452

    /// Create an empty cache (no nodes).

1453

    pub fn empty() -> Self {

1454

        Self {

1455

            tier1_enums: Vec::new(),

1456

            tier2_dims: Vec::new(),

1457

            tier2_cold: Vec::new(),

1458

            tier2b_text: Vec::new(),

1459

            font_dirty_nodes: Vec::new(),

1460

            prev_font_hashes: Vec::new(),

1461

            font_hash_to_families: alloc::collections::BTreeMap::new(),

1462

            dom_declared_flags: 0,

1463

1464

1465

1466

    /// Create a cache pre-allocated for `node_count` nodes, filled with defaults.

1467

8933

    pub fn with_capacity(node_count: usize) -> Self {

1468

8933

        Self {

1469

8933

            tier1_enums: vec![0u64; node_count],

1470

8933

            tier2_dims: vec![CompactNodeProps::default(); node_count],

1471

8933

            tier2_cold: vec![CompactNodePropsCold::default(); node_count],

1472

8933

            tier2b_text: vec![CompactTextProps::default(); node_count],

1473

8933

            font_dirty_nodes: Vec::new(),

1474

8933

            prev_font_hashes: vec![0u64; node_count],

1475

8933

            font_hash_to_families: alloc::collections::BTreeMap::new(),

1476

8933

            dom_declared_flags: 0,

1477

8933

1478

8933

1479

1480

    /// Number of nodes in this cache.

1481

    #[inline]

1482

    pub fn node_count(&self) -> usize {

1483

        self.tier1_enums.len()

1484

1485

1486

    // -- Tier 1 getters (enum properties) --

1487

1488

    #[inline(always)]

1489

525595

    pub fn get_display(&self, node_idx: usize) -> LayoutDisplay {

1490

525595

        decode_display(self.tier1_enums[node_idx])

1491

525595

1492

1493

    #[inline(always)]

1494

296485

    pub fn get_position(&self, node_idx: usize) -> LayoutPosition {

1495

296485

        decode_position(self.tier1_enums[node_idx])

1496

296485

1497

1498

    #[inline(always)]

1499

156940

    pub fn get_float(&self, node_idx: usize) -> LayoutFloat {

1500

156940

        decode_float(self.tier1_enums[node_idx])

1501

156940

1502

1503

    #[inline(always)]

1504

178465

    pub fn get_overflow_x(&self, node_idx: usize) -> LayoutOverflow {

1505

178465

        decode_overflow_x(self.tier1_enums[node_idx])

1506

178465

1507

1508

    #[inline(always)]

1509

190750

    pub fn get_overflow_y(&self, node_idx: usize) -> LayoutOverflow {

1510

190750

        decode_overflow_y(self.tier1_enums[node_idx])

1511

190750

1512

1513

    #[inline(always)]

1514

30310

    pub fn get_box_sizing(&self, node_idx: usize) -> LayoutBoxSizing {

1515

30310

        decode_box_sizing(self.tier1_enums[node_idx])

1516

30310

1517

1518

    #[inline(always)]

1519

980

    pub fn get_flex_direction(&self, node_idx: usize) -> LayoutFlexDirection {

1520

980

        decode_flex_direction(self.tier1_enums[node_idx])

1521

980

1522

1523

    #[inline(always)]

1524

665

    pub fn get_flex_wrap(&self, node_idx: usize) -> LayoutFlexWrap {

1525

665

        decode_flex_wrap(self.tier1_enums[node_idx])

1526

665

1527

1528

    #[inline(always)]

1529

    pub fn get_justify_content(&self, node_idx: usize) -> LayoutJustifyContent {

1530

        decode_justify_content(self.tier1_enums[node_idx])

1531

1532

1533

    #[inline(always)]

1534

665

    pub fn get_align_items(&self, node_idx: usize) -> LayoutAlignItems {

1535

665

        decode_align_items(self.tier1_enums[node_idx])

1536

665

1537

1538

    #[inline(always)]

1539

665

    pub fn get_align_content(&self, node_idx: usize) -> LayoutAlignContent {

1540

665

        decode_align_content(self.tier1_enums[node_idx])

1541

665

1542

1543

    #[inline(always)]

1544

122605

    pub fn get_writing_mode(&self, node_idx: usize) -> LayoutWritingMode {

1545

122605

        decode_writing_mode(self.tier1_enums[node_idx])

1546

122605

1547

1548

    #[inline(always)]

1549

15715

    pub fn get_clear(&self, node_idx: usize) -> LayoutClear {

1550

15715

        decode_clear(self.tier1_enums[node_idx])

1551

15715

1552

1553

    #[inline(always)]

1554

36505

    pub fn get_font_weight(&self, node_idx: usize) -> StyleFontWeight {

1555

36505

        decode_font_weight(self.tier1_enums[node_idx])

1556

36505

1557

1558

    #[inline(always)]

1559

36505

    pub fn get_font_style(&self, node_idx: usize) -> StyleFontStyle {

1560

36505

        decode_font_style(self.tier1_enums[node_idx])

1561

36505

1562

1563

    #[inline(always)]

1564

32340

    pub fn get_text_align(&self, node_idx: usize) -> StyleTextAlign {

1565

32340

        decode_text_align(self.tier1_enums[node_idx])

1566

32340

1567

1568

    #[inline(always)]

1569

86800

    pub fn get_visibility(&self, node_idx: usize) -> StyleVisibility {

1570

86800

        decode_visibility(self.tier1_enums[node_idx])

1571

86800

1572

1573

    #[inline(always)]

1574

41895

    pub fn get_white_space(&self, node_idx: usize) -> StyleWhiteSpace {

1575

41895

        decode_white_space(self.tier1_enums[node_idx])

1576

41895

1577

1578

    #[inline(always)]

1579

75355

    pub fn get_direction(&self, node_idx: usize) -> StyleDirection {

1580

75355

        decode_direction(self.tier1_enums[node_idx])

1581

75355

1582

1583

    #[inline(always)]

1584

    pub fn get_vertical_align(&self, node_idx: usize) -> StyleVerticalAlign {

1585

        decode_vertical_align(self.tier1_enums[node_idx])

1586

1587

1588

    #[inline(always)]

1589

1155

    pub fn get_border_collapse(&self, node_idx: usize) -> StyleBorderCollapse {

1590

1155

        decode_border_collapse(self.tier1_enums[node_idx])

1591

1155

1592

1593

    // -- Tier 2 getters (numeric dimensions) --

1594

1595

    /// Get width as encoded u32 (use `decode_pixel_value_u32` or check sentinel).

1596

    #[inline(always)]

1597

57435

    pub fn get_width_raw(&self, node_idx: usize) -> u32 {

1598

57435

        self.tier2_dims[node_idx].width

1599

57435

1600

1601

    #[inline(always)]

1602

85925

    pub fn get_height_raw(&self, node_idx: usize) -> u32 {

1603

85925

        self.tier2_dims[node_idx].height

1604

85925

1605

1606

    #[inline(always)]

1607

74620

    pub fn get_min_width_raw(&self, node_idx: usize) -> u32 {

1608

74620

        self.tier2_dims[node_idx].min_width

1609

74620

1610

1611

    #[inline(always)]

1612

55580

    pub fn get_max_width_raw(&self, node_idx: usize) -> u32 {

1613

55580

        self.tier2_dims[node_idx].max_width

1614

55580

1615

1616

    #[inline(always)]

1617

74620

    pub fn get_min_height_raw(&self, node_idx: usize) -> u32 {

1618

74620

        self.tier2_dims[node_idx].min_height

1619

74620

1620

1621

    #[inline(always)]

1622

55580

    pub fn get_max_height_raw(&self, node_idx: usize) -> u32 {

1623

55580

        self.tier2_dims[node_idx].max_height

1624

55580

1625

1626

    #[inline(always)]

1627

32970

    pub fn get_font_size_raw(&self, node_idx: usize) -> u32 {

1628

32970

        self.tier2_dims[node_idx].font_size

1629

32970

1630

1631

    #[inline(always)]

1632

665

    pub fn get_flex_basis_raw(&self, node_idx: usize) -> u32 {

1633

665

        self.tier2_dims[node_idx].flex_basis

1634

665

1635

1636

    /// Get padding-top as resolved px. Returns None if sentinel (needs slow path).

1637

    #[inline(always)]

1638

    pub fn get_padding_top(&self, node_idx: usize) -> Option<f32> {

1639

        decode_resolved_px_i16(self.tier2_dims[node_idx].padding_top)

1640

1641

1642

    #[inline(always)]

1643

    pub fn get_padding_right(&self, node_idx: usize) -> Option<f32> {

1644

        decode_resolved_px_i16(self.tier2_dims[node_idx].padding_right)

1645

1646

1647

    #[inline(always)]

1648

    pub fn get_padding_bottom(&self, node_idx: usize) -> Option<f32> {

1649

        decode_resolved_px_i16(self.tier2_dims[node_idx].padding_bottom)

1650

1651

1652

    #[inline(always)]

1653

    pub fn get_padding_left(&self, node_idx: usize) -> Option<f32> {

1654

        decode_resolved_px_i16(self.tier2_dims[node_idx].padding_left)

1655

1656

1657

    #[inline(always)]

1658

    pub fn get_margin_top(&self, node_idx: usize) -> Option<f32> {

1659

        let v = self.tier2_dims[node_idx].margin_top;

1660

        if v == I16_AUTO { return None; } // Auto for margin is special

1661

        decode_resolved_px_i16(v)

1662

1663

1664

    #[inline(always)]

1665

    pub fn get_margin_right(&self, node_idx: usize) -> Option<f32> {

1666

        let v = self.tier2_dims[node_idx].margin_right;

1667

        if v == I16_AUTO { return None; }

1668

        decode_resolved_px_i16(v)

1669

1670

1671

    #[inline(always)]

1672

    pub fn get_margin_bottom(&self, node_idx: usize) -> Option<f32> {

1673

        let v = self.tier2_dims[node_idx].margin_bottom;

1674

        if v == I16_AUTO { return None; }

1675

        decode_resolved_px_i16(v)

1676

1677

1678

    #[inline(always)]

1679

    pub fn get_margin_left(&self, node_idx: usize) -> Option<f32> {

1680

        let v = self.tier2_dims[node_idx].margin_left;

1681

        if v == I16_AUTO { return None; }

1682

        decode_resolved_px_i16(v)

1683

1684

1685

    /// Check if margin is Auto (important for centering logic).

1686

    #[inline(always)]

1687

    pub fn is_margin_top_auto(&self, node_idx: usize) -> bool {

1688

        self.tier2_dims[node_idx].margin_top == I16_AUTO

1689

1690

1691

    #[inline(always)]

1692

    pub fn is_margin_right_auto(&self, node_idx: usize) -> bool {

1693

        self.tier2_dims[node_idx].margin_right == I16_AUTO

1694

1695

1696

    #[inline(always)]

1697

    pub fn is_margin_bottom_auto(&self, node_idx: usize) -> bool {

1698

        self.tier2_dims[node_idx].margin_bottom == I16_AUTO

1699

1700

1701

    #[inline(always)]

1702

    pub fn is_margin_left_auto(&self, node_idx: usize) -> bool {

1703

        self.tier2_dims[node_idx].margin_left == I16_AUTO

1704

1705

1706

    #[inline(always)]

1707

    pub fn get_border_top_width(&self, node_idx: usize) -> Option<f32> {

1708

        decode_resolved_px_i16(self.tier2_dims[node_idx].border_top_width)

1709

1710

1711

    #[inline(always)]

1712

    pub fn get_border_right_width(&self, node_idx: usize) -> Option<f32> {

1713

        decode_resolved_px_i16(self.tier2_dims[node_idx].border_right_width)

1714

1715

1716

    #[inline(always)]

1717

    pub fn get_border_bottom_width(&self, node_idx: usize) -> Option<f32> {

1718

        decode_resolved_px_i16(self.tier2_dims[node_idx].border_bottom_width)

1719

1720

1721

    #[inline(always)]

1722

    pub fn get_border_left_width(&self, node_idx: usize) -> Option<f32> {

1723

        decode_resolved_px_i16(self.tier2_dims[node_idx].border_left_width)

1724

1725

1726

    // -- Raw i16 getters for macro fast paths --

1727

1728

    #[inline(always)]

1729

58905

    pub fn get_padding_top_raw(&self, node_idx: usize) -> i16 {

1730

58905

        self.tier2_dims[node_idx].padding_top

1731

58905

1732

1733

    #[inline(always)]

1734

58905

    pub fn get_padding_right_raw(&self, node_idx: usize) -> i16 {

1735

58905

        self.tier2_dims[node_idx].padding_right

1736

58905

1737

1738

    #[inline(always)]

1739

58905

    pub fn get_padding_bottom_raw(&self, node_idx: usize) -> i16 {

1740

58905

        self.tier2_dims[node_idx].padding_bottom

1741

58905

1742

1743

    #[inline(always)]

1744

58905

    pub fn get_padding_left_raw(&self, node_idx: usize) -> i16 {

1745

58905

        self.tier2_dims[node_idx].padding_left

1746

58905

1747

1748

    #[inline(always)]

1749

25935

    pub fn get_margin_top_raw(&self, node_idx: usize) -> i16 {

1750

25935

        self.tier2_dims[node_idx].margin_top

1751

25935

1752

1753

    #[inline(always)]

1754

25935

    pub fn get_margin_right_raw(&self, node_idx: usize) -> i16 {

1755

25935

        self.tier2_dims[node_idx].margin_right

1756

25935

1757

1758

    #[inline(always)]

1759

25935

    pub fn get_margin_bottom_raw(&self, node_idx: usize) -> i16 {

1760

25935

        self.tier2_dims[node_idx].margin_bottom

1761

25935

1762

1763

    #[inline(always)]

1764

25935

    pub fn get_margin_left_raw(&self, node_idx: usize) -> i16 {

1765

25935

        self.tier2_dims[node_idx].margin_left

1766

25935

1767

1768

    #[inline(always)]

1769

74375

    pub fn get_border_top_width_raw(&self, node_idx: usize) -> i16 {

1770

74375

        self.tier2_dims[node_idx].border_top_width

1771

74375

1772

1773

    #[inline(always)]

1774

74375

    pub fn get_border_right_width_raw(&self, node_idx: usize) -> i16 {

1775

74375

        self.tier2_dims[node_idx].border_right_width

1776

74375

1777

1778

    #[inline(always)]

1779

74375

    pub fn get_border_bottom_width_raw(&self, node_idx: usize) -> i16 {

1780

74375

        self.tier2_dims[node_idx].border_bottom_width

1781

74375

1782

1783

    #[inline(always)]

1784

74375

    pub fn get_border_left_width_raw(&self, node_idx: usize) -> i16 {

1785

74375

        self.tier2_dims[node_idx].border_left_width

1786

74375

1787

1788

    #[inline(always)]

1789

735

    pub fn get_top(&self, node_idx: usize) -> i16 {

1790

735

        self.tier2_dims[node_idx].top

1791

735

1792

1793

    #[inline(always)]

1794

735

    pub fn get_right(&self, node_idx: usize) -> i16 {

1795

735

        self.tier2_dims[node_idx].right

1796

735

1797

1798

    #[inline(always)]

1799

735

    pub fn get_bottom(&self, node_idx: usize) -> i16 {

1800

735

        self.tier2_dims[node_idx].bottom

1801

735

1802

1803

    #[inline(always)]

1804

735

    pub fn get_left(&self, node_idx: usize) -> i16 {

1805

735

        self.tier2_dims[node_idx].left

1806

735

1807

1808

    #[inline(always)]

1809

665

    pub fn get_flex_grow(&self, node_idx: usize) -> Option<f32> {

1810

665

        decode_flex_u16(self.tier2_dims[node_idx].flex_grow)

1811

665

1812

1813

    #[inline(always)]

1814

665

    pub fn get_flex_shrink(&self, node_idx: usize) -> Option<f32> {

1815

665

        decode_flex_u16(self.tier2_dims[node_idx].flex_shrink)

1816

665

1817

1818

    #[inline(always)]

1819

48650

    pub fn get_z_index(&self, node_idx: usize) -> i16 {

1820

48650

        self.tier2_cold[node_idx].z_index

1821

48650

1822

1823

    // -- Border colors (u32 RGBA) — cold tier --

1824

1825

    #[inline(always)]

1826

48440

    pub fn get_border_top_color_raw(&self, node_idx: usize) -> u32 {

1827

48440

        self.tier2_cold[node_idx].border_top_color

1828

48440

1829

1830

    #[inline(always)]

1831

48440

    pub fn get_border_right_color_raw(&self, node_idx: usize) -> u32 {

1832

48440

        self.tier2_cold[node_idx].border_right_color

1833

48440

1834

1835

    #[inline(always)]

1836

48440

    pub fn get_border_bottom_color_raw(&self, node_idx: usize) -> u32 {

1837

48440

        self.tier2_cold[node_idx].border_bottom_color

1838

48440

1839

1840

    #[inline(always)]

1841

48440

    pub fn get_border_left_color_raw(&self, node_idx: usize) -> u32 {

1842

48440

        self.tier2_cold[node_idx].border_left_color

1843

48440

1844

1845

    // -- Border styles (packed u16) — cold tier --

1846

1847

    #[inline(always)]

1848

    pub fn get_border_styles_packed(&self, node_idx: usize) -> u16 {

1849

        self.tier2_cold[node_idx].border_styles_packed

1850

1851

1852

    #[inline(always)]

1853

73710

    pub fn get_border_top_style(&self, node_idx: usize) -> BorderStyle {

1854

73710

        decode_border_top_style(self.tier2_cold[node_idx].border_styles_packed)

1855

73710

1856

1857

    #[inline(always)]

1858

73710

    pub fn get_border_right_style(&self, node_idx: usize) -> BorderStyle {

1859

73710

        decode_border_right_style(self.tier2_cold[node_idx].border_styles_packed)

1860

73710

1861

1862

    #[inline(always)]

1863

73710

    pub fn get_border_bottom_style(&self, node_idx: usize) -> BorderStyle {

1864

73710

        decode_border_bottom_style(self.tier2_cold[node_idx].border_styles_packed)

1865

73710

1866

1867

    #[inline(always)]

1868

73710

    pub fn get_border_left_style(&self, node_idx: usize) -> BorderStyle {

1869

73710

        decode_border_left_style(self.tier2_cold[node_idx].border_styles_packed)

1870

73710

1871

1872

    // -- Border spacing — cold tier --

1873

1874

    #[inline(always)]

1875

1155

    pub fn get_border_spacing_h_raw(&self, node_idx: usize) -> i16 {

1876

1155

        self.tier2_cold[node_idx].border_spacing_h

1877

1155

1878

1879

    #[inline(always)]

1880

1155

    pub fn get_border_spacing_v_raw(&self, node_idx: usize) -> i16 {

1881

1155

        self.tier2_cold[node_idx].border_spacing_v

1882

1155

1883

1884

    // -- Tab size — cold tier --

1885

1886

    #[inline(always)]

1887

32970

    pub fn get_tab_size_raw(&self, node_idx: usize) -> i16 {

1888

32970

        self.tier2_cold[node_idx].tab_size

1889

32970

1890

1891

    // -- Border radii — cold tier (i16 px × 10, I16_SENTINEL = unset = 0) --

1892

1893

    #[inline(always)]

1894

85820

    pub fn get_border_top_left_radius_raw(&self, node_idx: usize) -> i16 {

1895

85820

        self.tier2_cold[node_idx].border_top_left_radius

1896

85820

1897

1898

    #[inline(always)]

1899

85820

    pub fn get_border_top_right_radius_raw(&self, node_idx: usize) -> i16 {

1900

85820

        self.tier2_cold[node_idx].border_top_right_radius

1901

85820

1902

1903

    #[inline(always)]

1904

85820

    pub fn get_border_bottom_left_radius_raw(&self, node_idx: usize) -> i16 {

1905

85820

        self.tier2_cold[node_idx].border_bottom_left_radius

1906

85820

1907

1908

    #[inline(always)]

1909

85820

    pub fn get_border_bottom_right_radius_raw(&self, node_idx: usize) -> i16 {

1910

85820

        self.tier2_cold[node_idx].border_bottom_right_radius

1911

85820

1912

1913

    // -- Opacity / transform / hot flags --

1914

1915

    /// Raw opacity byte. `OPACITY_SENTINEL` (255) = unset (default = 1.0).

1916

    /// Otherwise value / 254.0 yields the opacity in [0.0, 1.0].

1917

    #[inline(always)]

1918

76650

    pub fn get_opacity_raw(&self, node_idx: usize) -> u8 {

1919

76650

        self.tier2_cold[node_idx].opacity

1920

76650

1921

1922

    #[inline(always)]

1923

    pub fn get_hot_flags(&self, node_idx: usize) -> u8 {

1924

        self.tier2_cold[node_idx].hot_flags

1925

1926

1927

    #[inline(always)]

1928

70350

    pub fn has_transform(&self, node_idx: usize) -> bool {

1929

70350

        self.tier2_cold[node_idx].hot_flags & HOT_FLAG_HAS_TRANSFORM != 0

1930

70350

1931

1932

    #[inline(always)]

1933

    pub fn has_transform_origin(&self, node_idx: usize) -> bool {

1934

        self.tier2_cold[node_idx].hot_flags & HOT_FLAG_HAS_TRANSFORM_ORIGIN != 0

1935

1936

1937

    #[inline(always)]

1938

61600

    pub fn has_box_shadow(&self, node_idx: usize) -> bool {

1939

61600

        self.tier2_cold[node_idx].hot_flags & HOT_FLAG_HAS_BOX_SHADOW != 0

1940

61600

1941

1942

    #[inline(always)]

1943

32970

    pub fn has_text_decoration(&self, node_idx: usize) -> bool {

1944

32970

        self.tier2_cold[node_idx].hot_flags & HOT_FLAG_HAS_TEXT_DECORATION != 0

1945

32970

1946

1947

    #[inline(always)]

1948

95620

    pub fn has_background(&self, node_idx: usize) -> bool {

1949

95620

        self.tier2_cold[node_idx].hot_flags & HOT_FLAG_HAS_BACKGROUND != 0

1950

95620

1951

1952

    #[inline(always)]

1953

26915

    pub fn has_clip_path(&self, node_idx: usize) -> bool {

1954

26915

        self.tier2_cold[node_idx].hot_flags & HOT_FLAG_HAS_CLIP_PATH != 0

1955

26915

1956

1957

    #[inline(always)]

1958

26810

    pub fn has_scrollbar_css(&self, node_idx: usize) -> bool {

1959

26810

        self.tier2_cold[node_idx].extra_flags & EXTRA_FLAG_HAS_SCROLLBAR_CSS != 0

1960

26810

1961

1962

    #[inline(always)]

1963

25270

    pub fn has_counter(&self, node_idx: usize) -> bool {

1964

25270

        self.tier2_cold[node_idx].extra_flags & EXTRA_FLAG_HAS_COUNTER != 0

1965

25270

1966

1967

    #[inline(always)]

1968

53620

    pub fn has_break(&self, node_idx: usize) -> bool {

1969

53620

        self.tier2_cold[node_idx].extra_flags & EXTRA_FLAG_HAS_BREAK != 0

1970

53620

1971

1972

    #[inline(always)]

1973

60865

    pub fn has_text_orientation(&self, node_idx: usize) -> bool {

1974

60865

        self.tier2_cold[node_idx].extra_flags & EXTRA_FLAG_HAS_TEXT_ORIENTATION != 0

1975

60865

1976

1977

    #[inline(always)]

1978

    pub fn has_text_shadow(&self, node_idx: usize) -> bool {

1979

        self.tier2_cold[node_idx].extra_flags & EXTRA_FLAG_HAS_TEXT_SHADOW != 0

1980

1981

1982

    #[inline(always)]

1983

    pub fn has_backdrop_filter(&self, node_idx: usize) -> bool {

1984

        self.tier2_cold[node_idx].extra_flags & EXTRA_FLAG_HAS_BACKDROP_FILTER != 0

1985

1986

1987

    #[inline(always)]

1988

    pub fn has_filter(&self, node_idx: usize) -> bool {

1989

        self.tier2_cold[node_idx].extra_flags & EXTRA_FLAG_HAS_FILTER != 0

1990

1991

1992

    #[inline(always)]

1993

    pub fn has_mix_blend_mode(&self, node_idx: usize) -> bool {

1994

        self.tier2_cold[node_idx].extra_flags & EXTRA_FLAG_HAS_MIX_BLEND_MODE != 0

1995

1996

1997

    /// DOM-level fast-path check: returns `true` if the given flag bit is set

1998

    /// (some node in this DOM declared the corresponding property).

1999

    #[inline(always)]

2000

    pub fn dom_declared(&self, flag: u32) -> bool {

2001

        self.dom_declared_flags & flag != 0

2002

2003

2004

    /// Scrollbar-gutter: 0 = auto (default), 1 = stable, 2 = both-edges, 3 = mirror.

2005

    #[inline(always)]

2006

47635

    pub fn get_scrollbar_gutter_bits(&self, node_idx: usize) -> u8 {

2007

47635

        (self.tier2_cold[node_idx].hot_flags & HOT_FLAG_SCROLLBAR_GUTTER_MASK)

2008

47635

            >> HOT_FLAG_SCROLLBAR_GUTTER_SHIFT

2009

47635

2010

2011

    // -- Tier 2b getters (text props) --

2012

2013

    #[inline(always)]

2014

32970

    pub fn get_text_color_raw(&self, node_idx: usize) -> u32 {

2015

32970

        self.tier2b_text[node_idx].text_color

2016

32970

2017

2018

    #[inline(always)]

2019

    pub fn get_font_family_hash(&self, node_idx: usize) -> u64 {

2020

        self.tier2b_text[node_idx].font_family_hash

2021

2022

2023

    #[inline(always)]

2024

32970

    pub fn get_line_height(&self, node_idx: usize) -> Option<f32> {

2025

32970

        decode_resolved_px_i16(self.tier2b_text[node_idx].line_height)

2026

32970

2027

2028

    #[inline(always)]

2029

32970

    pub fn get_letter_spacing(&self, node_idx: usize) -> Option<f32> {

2030

32970

        decode_resolved_px_i16(self.tier2b_text[node_idx].letter_spacing)

2031

32970

2032

2033

    #[inline(always)]

2034

32970

    pub fn get_word_spacing(&self, node_idx: usize) -> Option<f32> {

2035

32970

        decode_resolved_px_i16(self.tier2b_text[node_idx].word_spacing)

2036

32970

2037

2038

    #[inline(always)]

2039

    pub fn get_text_indent(&self, node_idx: usize) -> Option<f32> {

2040

        decode_resolved_px_i16(self.tier2b_text[node_idx].text_indent)

2041

2042

2043

2044

2045

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

2046

// Helper: encode a CssPropertyValue<PixelValue> into i16 resolved-px

2047

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

2048

2049

/// Resolve a CssPropertyValue<PixelValue> to an i16 ×10 encoding.

2050

/// Only handles `Exact(px(...))` values. Everything else → sentinel.

2051

/// For the compact cache builder, we only pre-resolve absolute pixel values.

2052

/// Relative units (em, %, etc.) get sentinel and fall back to the slow path.

2053

#[inline]

2054

144210

pub fn encode_css_pixel_as_i16(prop: &CssPropertyValue<PixelValue>) -> i16 {

2055

144210

    match prop {

2056

144126

        CssPropertyValue::Exact(pv) => {

2057

144126

            if pv.metric == SizeMetric::Px {

2058

141288

                encode_resolved_px_i16(pv.number.get())

2059

            } else {

2060

2838

                I16_SENTINEL // non-px units need resolution context → slow path

2061

2062

2063

84

        CssPropertyValue::Auto => I16_AUTO,

2064

        CssPropertyValue::Initial => I16_INITIAL,

2065

        CssPropertyValue::Inherit => I16_INHERIT,

2066

        _ => I16_SENTINEL,

2067

2068

144210

2069

2070

#[cfg(test)]

2071

mod tests {

2072

    use super::*;

2073

2074

    #[test]

2075

1

    fn test_tier1_roundtrip() {

2076

1

        let t1 = encode_tier1(

2077

1

            LayoutDisplay::Flex,

2078

1

            LayoutPosition::Relative,

2079

1

            LayoutFloat::Left,

2080

1

            LayoutOverflow::Hidden,

2081

1

            LayoutOverflow::Scroll,

2082

1

            LayoutBoxSizing::BorderBox,

2083

1

            LayoutFlexDirection::Column,

2084

1

            LayoutFlexWrap::Wrap,

2085

1

            LayoutJustifyContent::SpaceBetween,

2086

1

            LayoutAlignItems::Center,

2087

1

            LayoutAlignContent::End,

2088

1

            LayoutWritingMode::VerticalRl,

2089

1

            LayoutClear::Both,

2090

1

            StyleFontWeight::Bold,

2091

1

            StyleFontStyle::Italic,

2092

1

            StyleTextAlign::Center,

2093

1

            StyleVisibility::Hidden,

2094

1

            StyleWhiteSpace::Pre,

2095

1

            StyleDirection::Rtl,

2096

1

            StyleVerticalAlign::Middle,

2097

1

            StyleBorderCollapse::Collapse,

2098

);

2099

2100

1

        assert!(tier1_is_populated(t1));

2101

1

        assert_eq!(decode_display(t1), LayoutDisplay::Flex);

2102

1

        assert_eq!(decode_position(t1), LayoutPosition::Relative);

2103

1

        assert_eq!(decode_float(t1), LayoutFloat::Left);

2104

1

        assert_eq!(decode_overflow_x(t1), LayoutOverflow::Hidden);

2105

1

        assert_eq!(decode_overflow_y(t1), LayoutOverflow::Scroll);

2106

1

        assert_eq!(decode_box_sizing(t1), LayoutBoxSizing::BorderBox);

2107

1

        assert_eq!(decode_flex_direction(t1), LayoutFlexDirection::Column);

2108

1

        assert_eq!(decode_flex_wrap(t1), LayoutFlexWrap::Wrap);

2109

1

        assert_eq!(decode_justify_content(t1), LayoutJustifyContent::SpaceBetween);

2110

1

        assert_eq!(decode_align_items(t1), LayoutAlignItems::Center);

2111

1

        assert_eq!(decode_align_content(t1), LayoutAlignContent::End);

2112

1

        assert_eq!(decode_writing_mode(t1), LayoutWritingMode::VerticalRl);

2113

1

        assert_eq!(decode_clear(t1), LayoutClear::Both);

2114

1

        assert_eq!(decode_font_weight(t1), StyleFontWeight::Bold);

2115

1

        assert_eq!(decode_font_style(t1), StyleFontStyle::Italic);

2116

1

        assert_eq!(decode_text_align(t1), StyleTextAlign::Center);

2117

1

        assert_eq!(decode_visibility(t1), StyleVisibility::Hidden);

2118

1

        assert_eq!(decode_white_space(t1), StyleWhiteSpace::Pre);

2119

1

        assert_eq!(decode_direction(t1), StyleDirection::Rtl);

2120

1

        assert_eq!(decode_vertical_align(t1), StyleVerticalAlign::Middle);

2121

1

        assert_eq!(decode_border_collapse(t1), StyleBorderCollapse::Collapse);

2122

1

2123

2124

    #[test]

2125

1

    fn test_tier1_defaults() {

2126

1

        let t1 = encode_tier1(

2127

1

            LayoutDisplay::Block,

2128

1

            LayoutPosition::Static,

2129

1

            LayoutFloat::None,

2130

1

            LayoutOverflow::Visible,

2131

1

            LayoutOverflow::Visible,

2132

1

            LayoutBoxSizing::ContentBox,

2133

1

            LayoutFlexDirection::Row,

2134

1

            LayoutFlexWrap::NoWrap,

2135

1

            LayoutJustifyContent::FlexStart,

2136

1

            LayoutAlignItems::Stretch,

2137

1

            LayoutAlignContent::Stretch,

2138

1

            LayoutWritingMode::HorizontalTb,

2139

1

            LayoutClear::None,

2140

1

            StyleFontWeight::Normal,

2141

1

            StyleFontStyle::Normal,

2142

1

            StyleTextAlign::Left,

2143

1

            StyleVisibility::Visible,

2144

1

            StyleWhiteSpace::Normal,

2145

1

            StyleDirection::Ltr,

2146

1

            StyleVerticalAlign::Baseline,

2147

1

            StyleBorderCollapse::Separate,

2148

);

2149

2150

1

        assert!(tier1_is_populated(t1));

2151

1

        assert_eq!(decode_display(t1), LayoutDisplay::Block);

2152

1

        assert_eq!(decode_position(t1), LayoutPosition::Static);

2153

1

2154

2155

    #[test]

2156

1

    fn test_pixel_value_u32_roundtrip() {

2157

1

        let pv = PixelValue::px(123.456);

2158

1

        let encoded = encode_pixel_value_u32(&pv);

2159

1

        assert!(encoded < U32_SENTINEL_THRESHOLD);

2160

1

        let decoded = decode_pixel_value_u32(encoded).unwrap();

2161

1

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

2162

        // Check within precision (×1000)

2163

1

        assert!((decoded.number.get() - 123.456).abs() < 0.002);

2164

1

2165

2166

    #[test]

2167

1

    fn test_pixel_value_u32_percent() {

2168

1

        let pv = PixelValue {

2169

1

            metric: SizeMetric::Percent,

2170

1

            number: FloatValue::new(50.0),

2171

1

};

2172

1

        let encoded = encode_pixel_value_u32(&pv);

2173

1

        let decoded = decode_pixel_value_u32(encoded).unwrap();

2174

1

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

2175

1

        assert!((decoded.number.get() - 50.0).abs() < 0.002);

2176

1

2177

2178

    #[test]

2179

1

    fn test_sentinel_values() {

2180

1

        assert_eq!(decode_pixel_value_u32(U32_SENTINEL), None);

2181

1

        assert_eq!(decode_pixel_value_u32(U32_AUTO), None);

2182

1

        assert_eq!(decode_pixel_value_u32(U32_MIN_CONTENT), None);

2183

1

        assert_eq!(decode_resolved_px_i16(I16_SENTINEL), None);

2184

1

        assert_eq!(decode_resolved_px_i16(I16_AUTO), None);

2185

1

2186

2187

    #[test]

2188

1

    fn test_resolved_px_i16_roundtrip() {

2189

1

        let px = 123.4f32;

2190

1

        let encoded = encode_resolved_px_i16(px);

2191

1

        let decoded = decode_resolved_px_i16(encoded).unwrap();

2192

1

        assert!((decoded - 123.4).abs() < 0.11);

2193

2194

        // Negative values

2195

1

        let px = -50.7f32;

2196

1

        let encoded = encode_resolved_px_i16(px);

2197

1

        let decoded = decode_resolved_px_i16(encoded).unwrap();

2198

1

        assert!((decoded - (-50.7)).abs() < 0.11);

2199

1

2200

2201

    #[test]

2202

1

    fn test_flex_u16_roundtrip() {

2203

1

        let v = 2.5f32;

2204

1

        let encoded = encode_flex_u16(v);

2205

1

        let decoded = decode_flex_u16(encoded).unwrap();

2206

1

        assert!((decoded - 2.5).abs() < 0.011);

2207

1

2208

2209

    #[test]

2210

1

    fn test_compact_node_props_size() {

2211

        // 72B hot props: 8×u32 dimensions (32B) + 16×i16 box model (32B)

2212

        // + 2×u16 flex (4B) + 1×i16 order + align/pos tier1 bits (4B).

2213

1

        assert_eq!(core::mem::size_of::<CompactNodeProps>(), 72);

2214

1

2215

2216

    #[test]

2217

1

    fn test_compact_node_props_cold_size() {

2218

        // 48B cold props: 4×u32 border colors (16B) + 4×i16 border radii (8B)

2219

        // + 1×i16 z_index + 1×u16 border_styles_packed + 2×i16 border_spacing

2220

        // + 1×i16 tab_size + 4×i16 grid placement (8B) + 3×u8 (opacity,

2221

        // hot_flags, extra_flags) = 45B, padded to 48B for u32 alignment.

2222

1

        assert_eq!(core::mem::size_of::<CompactNodePropsCold>(), 48);

2223

1

2224

2225

    #[test]

2226

1

    fn test_compact_text_props_size() {

2227

1

        assert_eq!(core::mem::size_of::<CompactTextProps>(), 24);

2228

1

2229

2230

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

2231

    // Tier1 enum 0-sentinel contract

2232

//

2233

    // Tier1 packs 21 enums into a single u64. A bit run that is all zeros

2234

    // must decode to the CSS initial value of that property, because an

2235

    // unpopulated tier1 field is all zeros. If any encoder shifts so that

2236

    // `0 -> something-other-than-initial`, every node that didn't explicitly

2237

    // set the property silently gets the wrong default — which is exactly

2238

    // how the calc.c grid stretch regression shipped (Start encoded as 0,

2239

    // so every grid container reported justify-items: Start instead of

2240

    // the CSS default Stretch-for-grid, collapsing the calc button grid).

2241

//

2242

    // Test invariant: decoding a u8 of 0 for every enum yields the CSS

2243

    // initial value of that property.

2244

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

2245

2246

    #[test]

2247

1

    fn test_justify_items_zero_is_stretch() {

2248

        // CSS initial for justify-items is `normal`, which on a grid item

2249

        // behaves as `stretch`. The tier1 bit pattern 0 must round-trip to

2250

        // Stretch so unset grid containers don't collapse their items.

2251

1

        assert_eq!(layout_justify_items_from_u8(0), LayoutJustifyItems::Stretch);

2252

1

        assert_eq!(layout_justify_items_to_u8(LayoutJustifyItems::Stretch), 0);

2253

1

2254

2255

    #[test]

2256

1

    fn test_tier1_enum_zero_sentinel_is_css_initial() {

2257

1

        assert_eq!(layout_display_from_u8(0), LayoutDisplay::Block);

2258

1

        assert_eq!(layout_position_from_u8(0), LayoutPosition::Static);

2259

1

        assert_eq!(layout_float_from_u8(0), LayoutFloat::None);

2260

1

        assert_eq!(layout_overflow_from_u8(0), LayoutOverflow::Visible);

2261

1

        assert_eq!(layout_box_sizing_from_u8(0), LayoutBoxSizing::ContentBox);

2262

1

        assert_eq!(layout_flex_direction_from_u8(0), LayoutFlexDirection::Row);

2263

1

        assert_eq!(layout_flex_wrap_from_u8(0), LayoutFlexWrap::NoWrap);

2264

1

        assert_eq!(layout_justify_content_from_u8(0), LayoutJustifyContent::FlexStart);

2265

1

        assert_eq!(layout_align_items_from_u8(0), LayoutAlignItems::Stretch);

2266

1

        assert_eq!(layout_align_content_from_u8(0), LayoutAlignContent::Stretch);

2267

1

        assert_eq!(layout_align_self_from_u8(0), LayoutAlignSelf::Auto);

2268

1

        assert_eq!(layout_justify_self_from_u8(0), LayoutJustifySelf::Auto);

2269

1

        assert_eq!(layout_justify_items_from_u8(0), LayoutJustifyItems::Stretch);

2270

1

        assert_eq!(layout_grid_auto_flow_from_u8(0), LayoutGridAutoFlow::Row);

2271

1

        assert_eq!(layout_writing_mode_from_u8(0), LayoutWritingMode::HorizontalTb);

2272

1

        assert_eq!(layout_clear_from_u8(0), LayoutClear::None);

2273

1

        assert_eq!(style_font_weight_from_u8(0), StyleFontWeight::Normal);

2274

1

        assert_eq!(style_font_style_from_u8(0), StyleFontStyle::Normal);

2275

        // text-align initial is `start`; we collapse `start` → `left` on

2276

        // LTR runs at encode time, so the 0 slot decodes to Left.

2277

1

        assert_eq!(style_text_align_from_u8(0), StyleTextAlign::Left);

2278

1

        assert_eq!(style_visibility_from_u8(0), StyleVisibility::Visible);

2279

1

        assert_eq!(style_white_space_from_u8(0), StyleWhiteSpace::Normal);

2280

1

        assert_eq!(style_direction_from_u8(0), StyleDirection::Ltr);

2281

1

        assert_eq!(style_vertical_align_from_u8(0), StyleVerticalAlign::Baseline);

2282

1

        assert_eq!(border_collapse_from_u8(0), StyleBorderCollapse::Separate);

2283

1

2284

2285

    #[test]

2286

1

    fn test_tier1_enum_initial_encodes_to_zero() {

2287

        // Mirror of the above — encoding the CSS initial value must

2288

        // produce 0, otherwise an `all-zeros` tier1 bit run would encode

2289

        // a non-initial value and nodes without explicit properties would

2290

        // silently inherit the wrong default.

2291

1

        assert_eq!(layout_display_to_u8(LayoutDisplay::Block), 0);

2292

1

        assert_eq!(layout_position_to_u8(LayoutPosition::Static), 0);

2293

1

        assert_eq!(layout_float_to_u8(LayoutFloat::None), 0);

2294

1

        assert_eq!(layout_overflow_to_u8(LayoutOverflow::Visible), 0);

2295

1

        assert_eq!(layout_box_sizing_to_u8(LayoutBoxSizing::ContentBox), 0);

2296

1

        assert_eq!(layout_flex_direction_to_u8(LayoutFlexDirection::Row), 0);

2297

1

        assert_eq!(layout_flex_wrap_to_u8(LayoutFlexWrap::NoWrap), 0);

2298

1

        assert_eq!(layout_justify_content_to_u8(LayoutJustifyContent::FlexStart), 0);

2299

1

        assert_eq!(layout_align_items_to_u8(LayoutAlignItems::Stretch), 0);

2300

1

        assert_eq!(layout_align_content_to_u8(LayoutAlignContent::Stretch), 0);

2301

1

        assert_eq!(layout_align_self_to_u8(LayoutAlignSelf::Auto), 0);

2302

1

        assert_eq!(layout_justify_self_to_u8(LayoutJustifySelf::Auto), 0);

2303

1

        assert_eq!(layout_justify_items_to_u8(LayoutJustifyItems::Stretch), 0);

2304

1

        assert_eq!(layout_grid_auto_flow_to_u8(LayoutGridAutoFlow::Row), 0);

2305

1

        assert_eq!(layout_writing_mode_to_u8(LayoutWritingMode::HorizontalTb), 0);

2306

1

        assert_eq!(layout_clear_to_u8(LayoutClear::None), 0);

2307

1

        assert_eq!(style_font_weight_to_u8(StyleFontWeight::Normal), 0);

2308

1

        assert_eq!(style_font_style_to_u8(StyleFontStyle::Normal), 0);

2309

1

        assert_eq!(style_text_align_to_u8(StyleTextAlign::Left), 0);

2310

1

        assert_eq!(style_visibility_to_u8(StyleVisibility::Visible), 0);

2311

1

        assert_eq!(style_white_space_to_u8(StyleWhiteSpace::Normal), 0);

2312

1

        assert_eq!(style_direction_to_u8(StyleDirection::Ltr), 0);

2313

1

        assert_eq!(style_vertical_align_to_u8(StyleVerticalAlign::Baseline), 0);

2314

1

        assert_eq!(border_collapse_to_u8(StyleBorderCollapse::Separate), 0);

2315

1

2316

2317

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

2318

    // Exhaustive round-trip: every variant of every enum must survive

2319

    // encode → decode unchanged. Catches any reordering that maps two

2320

    // different variants to the same u8, or any mask-width mismatch.

2321

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

2322

2323

    macro_rules! roundtrip_all {

2324

        ($name:ident, $to:ident, $from:ident, [$($variant:expr),+ $(,)?]) => {

2325

            #[test]

2326

24

            fn $name() {

2327

155

                for v in [$($variant),+] {

2328

131

                    let u = $to(v);

2329

131

                    let decoded = $from(u);

2330

131

                    assert_eq!(decoded, v, "{:?} != {:?} (via u8 = {})", decoded, v, u);

2331

2332

24

2333

};

2334

2335

2336

    roundtrip_all!(rt_display, layout_display_to_u8, layout_display_from_u8, [

2337

        LayoutDisplay::Block, LayoutDisplay::Inline, LayoutDisplay::InlineBlock,

2338

        LayoutDisplay::Flex, LayoutDisplay::None, LayoutDisplay::InlineFlex,

2339

        LayoutDisplay::Table, LayoutDisplay::InlineTable, LayoutDisplay::TableRowGroup,

2340

        LayoutDisplay::TableHeaderGroup, LayoutDisplay::TableFooterGroup,

2341

        LayoutDisplay::TableRow, LayoutDisplay::TableColumnGroup,

2342

        LayoutDisplay::TableColumn, LayoutDisplay::TableCell,

2343

        LayoutDisplay::TableCaption, LayoutDisplay::FlowRoot,

2344

        LayoutDisplay::ListItem, LayoutDisplay::RunIn, LayoutDisplay::Marker,

2345

        LayoutDisplay::Grid, LayoutDisplay::InlineGrid, LayoutDisplay::Contents,

2346

]);

2347

2348

    roundtrip_all!(rt_position, layout_position_to_u8, layout_position_from_u8, [

2349

        LayoutPosition::Static, LayoutPosition::Relative, LayoutPosition::Absolute,

2350

        LayoutPosition::Fixed, LayoutPosition::Sticky,

2351

]);

2352

2353

    roundtrip_all!(rt_float, layout_float_to_u8, layout_float_from_u8, [

2354

        LayoutFloat::None, LayoutFloat::Left, LayoutFloat::Right,

2355

]);

2356

2357

    roundtrip_all!(rt_overflow, layout_overflow_to_u8, layout_overflow_from_u8, [

2358

        LayoutOverflow::Visible, LayoutOverflow::Hidden, LayoutOverflow::Scroll,

2359

        LayoutOverflow::Auto, LayoutOverflow::Clip,

2360

]);

2361

2362

    roundtrip_all!(rt_box_sizing, layout_box_sizing_to_u8, layout_box_sizing_from_u8, [

2363

        LayoutBoxSizing::ContentBox, LayoutBoxSizing::BorderBox,

2364

]);

2365

2366

    roundtrip_all!(rt_flex_direction, layout_flex_direction_to_u8, layout_flex_direction_from_u8, [

2367

        LayoutFlexDirection::Row, LayoutFlexDirection::RowReverse,

2368

        LayoutFlexDirection::Column, LayoutFlexDirection::ColumnReverse,

2369

]);

2370

2371

    roundtrip_all!(rt_flex_wrap, layout_flex_wrap_to_u8, layout_flex_wrap_from_u8, [

2372

        LayoutFlexWrap::NoWrap, LayoutFlexWrap::Wrap, LayoutFlexWrap::WrapReverse,

2373

]);

2374

2375

    roundtrip_all!(rt_justify_content, layout_justify_content_to_u8, layout_justify_content_from_u8, [

2376

        LayoutJustifyContent::FlexStart, LayoutJustifyContent::FlexEnd,

2377

        LayoutJustifyContent::Start, LayoutJustifyContent::End,

2378

        LayoutJustifyContent::Center, LayoutJustifyContent::SpaceBetween,

2379

        LayoutJustifyContent::SpaceAround, LayoutJustifyContent::SpaceEvenly,

2380

]);

2381

2382

    roundtrip_all!(rt_align_items, layout_align_items_to_u8, layout_align_items_from_u8, [

2383

        LayoutAlignItems::Stretch, LayoutAlignItems::Center, LayoutAlignItems::Start,

2384

        LayoutAlignItems::End, LayoutAlignItems::Baseline,

2385

]);

2386

2387

    roundtrip_all!(rt_align_self, layout_align_self_to_u8, layout_align_self_from_u8, [

2388

        LayoutAlignSelf::Auto, LayoutAlignSelf::Stretch, LayoutAlignSelf::Center,

2389

        LayoutAlignSelf::Start, LayoutAlignSelf::End, LayoutAlignSelf::Baseline,

2390

]);

2391

2392

    roundtrip_all!(rt_justify_self, layout_justify_self_to_u8, layout_justify_self_from_u8, [

2393

        LayoutJustifySelf::Auto, LayoutJustifySelf::Start, LayoutJustifySelf::End,

2394

        LayoutJustifySelf::Center, LayoutJustifySelf::Stretch,

2395

]);

2396

2397

    roundtrip_all!(rt_justify_items, layout_justify_items_to_u8, layout_justify_items_from_u8, [

2398

        LayoutJustifyItems::Stretch, LayoutJustifyItems::Start,

2399

        LayoutJustifyItems::End, LayoutJustifyItems::Center,

2400

]);

2401

2402

    roundtrip_all!(rt_grid_auto_flow, layout_grid_auto_flow_to_u8, layout_grid_auto_flow_from_u8, [

2403

        LayoutGridAutoFlow::Row, LayoutGridAutoFlow::Column,

2404

        LayoutGridAutoFlow::RowDense, LayoutGridAutoFlow::ColumnDense,

2405

]);

2406

2407

    roundtrip_all!(rt_align_content, layout_align_content_to_u8, layout_align_content_from_u8, [

2408

        LayoutAlignContent::Stretch, LayoutAlignContent::Center,

2409

        LayoutAlignContent::Start, LayoutAlignContent::End,

2410

        LayoutAlignContent::SpaceBetween, LayoutAlignContent::SpaceAround,

2411

]);

2412

2413

    roundtrip_all!(rt_writing_mode, layout_writing_mode_to_u8, layout_writing_mode_from_u8, [

2414

        LayoutWritingMode::HorizontalTb, LayoutWritingMode::VerticalRl,

2415

        LayoutWritingMode::VerticalLr,

2416

]);

2417

2418

    roundtrip_all!(rt_clear, layout_clear_to_u8, layout_clear_from_u8, [

2419

        LayoutClear::None, LayoutClear::Left, LayoutClear::Right, LayoutClear::Both,

2420

]);

2421

2422

    roundtrip_all!(rt_font_weight, style_font_weight_to_u8, style_font_weight_from_u8, [

2423

        StyleFontWeight::Normal, StyleFontWeight::W100, StyleFontWeight::W200,

2424

        StyleFontWeight::W300, StyleFontWeight::W500, StyleFontWeight::W600,

2425

        StyleFontWeight::Bold, StyleFontWeight::W800, StyleFontWeight::W900,

2426

        StyleFontWeight::Lighter, StyleFontWeight::Bolder,

2427

]);

2428

2429

    roundtrip_all!(rt_font_style, style_font_style_to_u8, style_font_style_from_u8, [

2430

        StyleFontStyle::Normal, StyleFontStyle::Italic, StyleFontStyle::Oblique,

2431

]);

2432

2433

    roundtrip_all!(rt_text_align, style_text_align_to_u8, style_text_align_from_u8, [

2434

        StyleTextAlign::Left, StyleTextAlign::Center, StyleTextAlign::Right,

2435

        StyleTextAlign::Justify, StyleTextAlign::Start, StyleTextAlign::End,

2436

]);

2437

2438

    roundtrip_all!(rt_visibility, style_visibility_to_u8, style_visibility_from_u8, [

2439

        StyleVisibility::Visible, StyleVisibility::Hidden, StyleVisibility::Collapse,

2440

]);

2441

2442

    roundtrip_all!(rt_white_space, style_white_space_to_u8, style_white_space_from_u8, [

2443

        StyleWhiteSpace::Normal, StyleWhiteSpace::Pre, StyleWhiteSpace::Nowrap,

2444

        StyleWhiteSpace::PreWrap, StyleWhiteSpace::PreLine, StyleWhiteSpace::BreakSpaces,

2445

]);

2446

2447

    roundtrip_all!(rt_direction, style_direction_to_u8, style_direction_from_u8, [

2448

        StyleDirection::Ltr, StyleDirection::Rtl,

2449

]);

2450

2451

    roundtrip_all!(rt_vertical_align, style_vertical_align_to_u8, style_vertical_align_from_u8, [

2452

        StyleVerticalAlign::Baseline, StyleVerticalAlign::Top, StyleVerticalAlign::Middle,

2453

        StyleVerticalAlign::Bottom, StyleVerticalAlign::Sub, StyleVerticalAlign::Superscript,

2454

        StyleVerticalAlign::TextTop, StyleVerticalAlign::TextBottom,

2455

]);

2456

2457

    roundtrip_all!(rt_border_collapse, border_collapse_to_u8, border_collapse_from_u8, [

2458

        StyleBorderCollapse::Separate, StyleBorderCollapse::Collapse,

2459

]);

2460

2461

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

2462

    // Bit-layout safety: every encoder must produce a u8 whose bits all

2463

    // fit inside the mask allocated for that property in the tier1 u64.

2464

    // If an enum grows a new variant that overflows its mask, the encoded

2465

    // bits would leak into the next property's slot and silently corrupt

2466

    // unrelated state.

2467

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

2468

2469

    #[test]

2470

1

    fn test_encoded_u8_fits_in_tier1_mask() {

2471

24

        fn assert_fits(name: &str, val: u8, mask: u64) {

2472

24

            assert!(

2473

24

                (val as u64) & !mask == 0,

2474

                "{}: encoded u8 {} overflows mask {:b}",

2475

                name, val, mask,

2476

);

2477

24

2478

2479

1

        assert_fits("display", layout_display_to_u8(LayoutDisplay::Contents), DISPLAY_MASK);

2480

1

        assert_fits("position", layout_position_to_u8(LayoutPosition::Sticky), POSITION_MASK);

2481

1

        assert_fits("float", layout_float_to_u8(LayoutFloat::Right), FLOAT_MASK);

2482

1

        assert_fits("overflow", layout_overflow_to_u8(LayoutOverflow::Clip), OVERFLOW_MASK);

2483

1

        assert_fits("box_sizing", layout_box_sizing_to_u8(LayoutBoxSizing::BorderBox), BOX_SIZING_MASK);

2484

1

        assert_fits("flex_direction", layout_flex_direction_to_u8(LayoutFlexDirection::ColumnReverse), FLEX_DIR_MASK);

2485

1

        assert_fits("flex_wrap", layout_flex_wrap_to_u8(LayoutFlexWrap::WrapReverse), FLEX_WRAP_MASK);

2486

1

        assert_fits("justify_content", layout_justify_content_to_u8(LayoutJustifyContent::SpaceEvenly), JUSTIFY_MASK);

2487

1

        assert_fits("align_items", layout_align_items_to_u8(LayoutAlignItems::Baseline), ALIGN_MASK);

2488

1

        assert_fits("align_self", layout_align_self_to_u8(LayoutAlignSelf::Baseline), ALIGN_SELF_MASK);

2489

1

        assert_fits("justify_self", layout_justify_self_to_u8(LayoutJustifySelf::Stretch), JUSTIFY_SELF_MASK);

2490

1

        assert_fits("justify_items", layout_justify_items_to_u8(LayoutJustifyItems::Center), JUSTIFY_ITEMS_MASK);

2491

1

        assert_fits("grid_auto_flow", layout_grid_auto_flow_to_u8(LayoutGridAutoFlow::ColumnDense), GRID_AUTO_FLOW_MASK);

2492

1

        assert_fits("align_content", layout_align_content_to_u8(LayoutAlignContent::SpaceAround), ALIGN_MASK);

2493

1

        assert_fits("writing_mode", layout_writing_mode_to_u8(LayoutWritingMode::VerticalLr), WRITING_MODE_MASK);

2494

1

        assert_fits("clear", layout_clear_to_u8(LayoutClear::Both), CLEAR_MASK);

2495

1

        assert_fits("font_weight", style_font_weight_to_u8(StyleFontWeight::Bolder), FONT_WEIGHT_MASK);

2496

1

        assert_fits("font_style", style_font_style_to_u8(StyleFontStyle::Oblique), FONT_STYLE_MASK);

2497

1

        assert_fits("text_align", style_text_align_to_u8(StyleTextAlign::End), TEXT_ALIGN_MASK);

2498

1

        assert_fits("visibility", style_visibility_to_u8(StyleVisibility::Collapse), VISIBILITY_MASK);

2499

1

        assert_fits("white_space", style_white_space_to_u8(StyleWhiteSpace::BreakSpaces), WHITE_SPACE_MASK);

2500

1

        assert_fits("direction", style_direction_to_u8(StyleDirection::Rtl), DIRECTION_MASK);

2501

1

        assert_fits("vertical_align", style_vertical_align_to_u8(StyleVerticalAlign::TextBottom), VERTICAL_ALIGN_MASK);

2502

1

        assert_fits("border_collapse", border_collapse_to_u8(StyleBorderCollapse::Collapse), BORDER_COLLAPSE_MASK);

2503

1

2504

2505

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

2506

    // Empty tier1 decodes to all-initial — this is the core contract that

2507

    // was violated by the pre-fix justify_items encoding. An empty u64 with

2508

    // only TIER1_POPULATED_BIT set must decode every property to its CSS

2509

    // initial value; this is how `build_compact_cache` can leave unspecified

2510

    // properties at 0 and still produce the correct cascade result.

2511

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

2512

2513

    #[test]

2514

1

    fn test_empty_tier1_decodes_to_initial_values() {

2515

1

        let t1 = TIER1_POPULATED_BIT; // populated, but zero content

2516

1

        assert!(tier1_is_populated(t1));

2517

1

        assert_eq!(decode_display(t1), LayoutDisplay::Block);

2518

1

        assert_eq!(decode_position(t1), LayoutPosition::Static);

2519

1

        assert_eq!(decode_float(t1), LayoutFloat::None);

2520

1

        assert_eq!(decode_overflow_x(t1), LayoutOverflow::Visible);

2521

1

        assert_eq!(decode_overflow_y(t1), LayoutOverflow::Visible);

2522

1

        assert_eq!(decode_box_sizing(t1), LayoutBoxSizing::ContentBox);

2523

1

        assert_eq!(decode_flex_direction(t1), LayoutFlexDirection::Row);

2524

1

        assert_eq!(decode_flex_wrap(t1), LayoutFlexWrap::NoWrap);

2525

1

        assert_eq!(decode_justify_content(t1), LayoutJustifyContent::FlexStart);

2526

1

        assert_eq!(decode_align_items(t1), LayoutAlignItems::Stretch);

2527

1

        assert_eq!(decode_align_content(t1), LayoutAlignContent::Stretch);

2528

1

        assert_eq!(decode_writing_mode(t1), LayoutWritingMode::HorizontalTb);

2529

1

        assert_eq!(decode_clear(t1), LayoutClear::None);

2530

1

        assert_eq!(decode_font_weight(t1), StyleFontWeight::Normal);

2531

1

        assert_eq!(decode_font_style(t1), StyleFontStyle::Normal);

2532

1

        assert_eq!(decode_text_align(t1), StyleTextAlign::Left);

2533

1

        assert_eq!(decode_visibility(t1), StyleVisibility::Visible);

2534

1

        assert_eq!(decode_white_space(t1), StyleWhiteSpace::Normal);

2535

1

        assert_eq!(decode_direction(t1), StyleDirection::Ltr);

2536

1

        assert_eq!(decode_vertical_align(t1), StyleVerticalAlign::Baseline);

2537

1

        assert_eq!(decode_border_collapse(t1), StyleBorderCollapse::Separate);

2538

1

2539