input[type='radio']{
    display: none;
}

/* Spans the dashboard so the percentage widths inside it resolve against the
   dashboard rather than against the table's own content width. */
.boardTableFrame{
    width: 100%;
    margin-left: auto;
    margin-right: auto;
}

#boardAvatarSizeButton{
    flex: 0 0 auto;
}

/* The button holds a glyph for each size (see board.php) and shows only the
   one for the size in use. */
#boardAvatarSizeButton .boardAvatarSizeGlyph{
    display: none;
}

#boardAvatarSizeButton[data-avatar-size="off"] .boardAvatarSizeGlyph--off,
#boardAvatarSizeButton[data-avatar-size="small"] .boardAvatarSizeGlyph--small,
#boardAvatarSizeButton[data-avatar-size="large"] .boardAvatarSizeGlyph--large{
    display: inline-block;
}

/* Large's own drawing, on a grid a quarter taller than Font Awesome's square
   em, so it stands a quarter taller than the others. */
#boardAvatarSizeButton .boardAvatarSizeGlyph--large{
    width: 1em;
    height: 1.25em;
    fill: currentColor;
    /* The bottom circle reaches the drawing's lower edge, and the edge the
       browser clips an SVG to is rounded to whole pixels, which shaved the
       circle flat. The drawing never leaves its grid, so nothing is clipped. */
    overflow: visible;
}

/* The three states, as one size, --board-avatar-size, which both the avatars
   and the rows' geometry below read, so the two cannot drift apart. Large is
   the size the avatars have always been - .entryProfileLink's own 1.8rem in
   main.css.

   Small is 1.25rem because that is the height of the entry name's own line box:
   anything at or below it leaves the row as short as the text alone makes it,
   which is the whole point of the setting, and this is the largest avatar that
   still reads as a deliberate step down from Large. Switched off, the avatar
   goes rather than shrinking further - by then the row is already as short as
   it goes, so what off buys is the width back; it takes no height either. */
:root{
    --board-avatar-size: 1.8rem;
}

:root[data-board-avatar-size="small"]{
    --board-avatar-size: 1.25rem;
}

:root[data-board-avatar-size="off"]{
    --board-avatar-size: 0px;
}

#boardTable .entryProfileLink{
    --size: var(--board-avatar-size);
}

#boardPage[data-avatar-size="off"] #boardTable .entryProfileLink{
    display: none;
}

/* --- A row's geometry -------------------------------------------------------
   Every row's cells sit inside a transparent border, and the gap between two
   pills, across a row and down a column alike, is two of those borders and two
   of a pick cell's insets. A row is as tall as its tallest content: the pill
   with its inset, or - with large avatars - the avatar with the name cell's
   inset. So that the gap down a column stays the gap across a row whatever the
   avatars' size, the pills take the row's whole height inside their insets
   rather than a fixed one: a taller avatar makes taller pills, never wider
   gaps. Each length is named once here and used both where it is set and in
   the arithmetic, so changing one cannot leave the other behind. The name's
   own line (1.25rem, see Small above) is never the tallest content, so it is
   not counted. */
/* A selection cell's one size and spacing, wherever it is drawn: the Board, its
   legend and distribution, the pick history modal, and the Overview's My Picks.
   The width is the same 52 as $boardFixedColumnWidth in board.php, whose table
   widths add it up. Off the Board the pills still take the height the Board's
   avatar setting gives them, so a selection is one size everywhere. */
:root{
    --board-fixed-col-width: 52px;
    --board-cell-border: 1px;
    --board-pick-inset: 2px;
    /* The room a cell keeps around its pill. Two neighbouring cells double it, so
       the first and last rows take it once more against the table's edges. */
    --board-cell-edge: calc(var(--board-cell-border) + var(--board-pick-inset));
    --board-name-inset: 1px;
    --board-pill-min-height: 22px;
    --board-row-inner-height: max(
        var(--board-pill-min-height) + 2 * var(--board-pick-inset),
        var(--board-avatar-size) + 2 * var(--board-name-inset)
    );
    --pick-pill-height: calc(var(--board-row-inner-height) - 2 * var(--board-pick-inset));
}

#boardTable .boardTableRow > td{
    border-width: var(--board-cell-border);
}

#boardTable .boardEntryName{
    padding-block: var(--board-name-inset);
}

/* With the avatar gone the name carries its tooltip: site.js moves the one
   tooltip element into .entryProfileContent, which starts at the column's left
   edge as the avatar did, so the tooltip is shown and placed by the same rules
   as when the avatar is there - see the Board and Standings tooltip rules in
   main.css. */

/* Sits in the right-hand tool group, so the group itself handles the right
   alignment — no auto margin needed. Its wrapper is a flex box, so it is
   exactly the button's height and the divider before it centres on the
   button. */
.boardDistributionWrap{
    display: flex;
    flex: 0 0 auto;
}

.boardDistributionButton:disabled{
    cursor: default;
}

/* The rule above walks the DOM, which knows nothing of where the grid broke the
   list into columns, so the card opening each column would carry a border along
   the top of that column. The class is written server-side in board.php,
   where the row count the grid fills to is already known - :nth-child cannot be
   used for it, because that row count moves with the number of teams playing.

   Only while the grid fills by column. Below the breakpoint it fills by row
   again, every card starts its own row, and the marked ones are nothing
   special - blanking their border there would cut holes in the list. */

/* Four columns stop being readable long before the panel reaches phone width,
   and the column fill has no way to reflow on its own - the row count is fixed.
   Below this the list goes back to filling by row, as many columns as fit. */

/* The Board's width, worked out once for the table and the controls above it.
   Every column but the entry name's is a fixed width that board.php publishes
   (their total is --board-fixed-sum). The name column takes what the page has
   left beside them, but never more than --board-name-max or less than
   --board-name-min. So the table is exactly as wide as its columns: centred
   with margins either side on a wide page, its name column narrowing on a
   tighter one, and scrolling sideways on a page narrower than its narrowest.

   The page is measured, not the table: under `table-layout: fixed`, Chrome
   hands an auto column - or one sized as a share of the table - only half the
   room left beside the fixed columns, and leaves the other half empty at the
   table's right. A width worked out here is a plain length, which both engines
   lay out alike. #boardPage is the container, so 100cqw is the room the
   Board has, inside the dashboard panel's padding. */
#boardPage{
    container-type: inline-size;
    --board-name-width: clamp(
        var(--board-name-min, 160px),
        calc(100cqw - var(--board-fixed-sum, 0px)),
        var(--board-name-max, 208px)
    );
    --board-live-width: calc(var(--board-fixed-sum, 0px) + var(--board-name-width));
}

#boardOptionsBar{
    width: var(--board-live-width);
    margin: 0 auto;
}

.boardOptionsToolRow{
    display: flex;
    align-items: center;
    margin-top: 8px;
    margin-bottom: 8px;
    font-weight: var(--fw1);
}

/* The first row is the first thing on the page - the week row, or where a
   league has none, the row under it - and the space above it is the hero's gap
   alone (see .pageHero in dashboard.css). */
#boardOptionsBar > .boardOptionsToolRow:first-child{
    margin-top: 0;
}

/* Pick 5 sizes both control rows to the table below them. The table's width is
   a pixel total computed in board.php ($boardPick5TableWidth), which
   that page publishes on #boardPage as --board-table-width, so the rows
   follow it automatically as the column counts change. */
.boardPage--pick5 .boardSearchBar,
.boardPage--pick5 .boardOptionsToolRow{
    width: var(--board-table-width);
    margin-left: auto;
    margin-right: auto;
}

.boardToolGroup{
    display: flex;
    align-items: center;
    gap: var(--g1);
}

.boardToolGroup--left{
    flex: 1;
    justify-content: flex-start;
}

.boardToolGroup--right{
    flex: 1;
    justify-content: flex-end;
}

/* The results status at the right end of the tool row, with Reset to actual
   after it - see #boardResultsStatus in board.php. */
.boardResultsStatus{
    display: flex;
    align-items: center;
    gap: var(--g1);
    font-family: var(--ff-body);
    font-size: var(--fs-small1);
    color: var(--c-text-muted);
}

.boardResultsStatusText{
    margin: 0;
    font-variant-numeric: tabular-nums;
}

/* ---------- Week win odds ---------- */

/* Sits in the table's own header cell above the entry names, left of the Reset
   button and the game headers. Label stacked over the value, both centred in the
   cell; the cell is otherwise empty and spans both header rows. */
/* Fills the header cell so its two lines can be aligned independently: the
   label against the top left corner, the value centred on the cell beneath it.
   Stretching the children is what lets one go left and the other centre - with
   align-items:center both would shrink to their own text and centre together. */
/* Stretched over the header cell rather than sized by its own content, so the
   value can be centred against the cell itself. height:100% will not do it: a
   percentage height has nothing definite to resolve against inside a table
   cell. The label is taken out of flow below, which leaves the value as the
   only thing this centres. */
/* The label over the number, the pair centred in the cell. */
.weekOddsTracker{
    align-items: center;
    display: flex;
    flex-direction: column;
    font-family: var(--ff-body);
    inset: 0;
    justify-content: center;
    line-height: 1.1;
    position: absolute;
    /* Laid over the whole cell, but only for placing its lines: the pointer
       goes through it, and only the number and its open breakdown answer (see
       below). Otherwise pointing anywhere in the cell opened the breakdown.
       :hover still reaches this element from the number inside it, so the
       rules that show the breakdown are unchanged. */
    pointer-events: none;
}

/* The tracker's contents, the label stacked over the number. */
/* As wide as it gets with two values both reading 100%, whatever it holds, so it
   does not change size as the odds do. */
.weekOddsButton{
    align-items: center;
    box-sizing: border-box;
    cursor: pointer;
    pointer-events: auto;
    display: flex;
    flex-direction: column;
    padding: 8px 12px;
    background: var(--c1-n4);
    /*border: 1px solid var(--c-league-theme-ink);*/
    border-radius: var(--r2);
    box-shadow: var(--elev-3);
    transition: box-shadow var(--shadow-duration) var(--shadow-easing);
    width: 173px;
}

/* Raised above a button's usual level, its fill being too pale to show that one,
   and it presses as a button does (elevation.css): up a level under the pointer,
   down below where it rests while pressed. */
.weekOddsButton:hover{
    box-shadow: var(--elev-4);
}

.weekOddsButton:active{
    box-shadow: var(--elev-1);
}

.weekOddsButton:focus-visible{
    box-shadow: var(--ring), var(--elev-3);
    outline: none;
}

.weekOddsValue,
.weekOddsBreakdown{
    pointer-events: auto;
}

.weekOddsTracker[hidden]{
    display: none;
}

/* The spanner head beside the places, centred on each other, so a league with
   one place has it level with the middle of the head. */
.weekOddsMain{
    align-items: center;
    column-gap: var(--g2);
    display: flex;
}

/* The spanner head (.tableSpannerHead), in the type of the th it sits in, on three
   lines, with its line stood up along its right side, the height of the head or
   the places, whichever is taller. */
.weekOddsLabel{
    align-items: center;
    align-self: stretch;
    display: flex;
    flex: 0 0 auto;
    line-height: 1.2;
    padding: 0 var(--g2) 0 0;
    position: relative;
    text-align: center;
    white-space: nowrap;
}

.weekOddsLabel::after{
    height: auto;
    inset: 0 0 0 auto;
    margin: 0;
    position: absolute;
    width: 1px;
}

/* The places stacked, 1st and, where the league pays more than one each week,
   Top #: the sub-heads in one column, in the th's type, and the numbers beside
   them in another, centred on each other. */
.weekOddsPlaces{
    align-items: center;
    column-gap: var(--g2);
    display: grid;
    /* The numbers' column is as wide as 100%, so nothing moves as they change. */
    grid-template-columns: auto 48px;
    line-height: 1.2;
    row-gap: var(--g1);
    white-space: nowrap;
}

.weekOddsPlace{
    display: contents;
}

.weekOddsPlace[hidden]{
    display: none;
}

/* The box that answers the pointer is the number itself and nothing more: no
   padding or margin around it, and text-box trims the line box from the font's
   full ascent and descent down to the digits, which run from the baseline to
   the cap height. Without the trim the box stood well above and below the
   figures, and hovering that empty band opened the breakdown. */
.weekOddsValue{
    font-variant-numeric: tabular-nums;
    letter-spacing: normal;
    justify-self: end;
    text-align: right;
    appearance: none;
    -webkit-appearance: none;
    background: transparent;
    border: 0;
    border-radius: var(--r2);
    color: var(--c-text-primary);
    cursor: pointer;
    font-family: var(--ff1);
    font-size: var(--fs-big2);
    font-weight: var(--fw4);
    line-height: 1;
    margin: 0;
    padding: 0;
    text-box: trim-both cap alphabetic;
}

/* Top # has no breakdown of its own, so pointing at it does not open 1st's. */
.weekOddsValue--top{
    pointer-events: none;
}

/* The Odds column's menu of what it shows, under its header, on a line of its own.
   Its words and its list are its own: a th's capitals and spacing are not for them. */
.selectMenuField:has(> #boardOddsPlace){
    display: flex;
    justify-content: center;
    letter-spacing: normal;
    text-transform: none;
}

.selectMenuField:has(> #boardOddsPlace) .selectMenuButton{
    height: auto;
    justify-content: center;
    width: auto;
}

/* The Odds column: each entry's chance of finishing first, to the nearest whole
   percent, its digits lined up, with the longest figure, "100%" at about 4.5ch,
   centred under the label. */
#boardTable td.boardOddsCell{
    box-sizing: border-box;
    color: var(--c-text-muted);
    font-variant-numeric: tabular-nums;
    padding-left: 0;
    padding-right: calc(var(--width-stat) / 2 - 2.25ch);
    text-align: right;
    white-space: nowrap;
}

/* The room of the percent sign beside a dash. A pseudo-element, so it is no
   part of the cell's text. */
.boardOddsReserve::after{
    content: "%";
    visibility: hidden;
}

.weekOddsBreakdown{
    /* The week CSE tooltip's dark look - see .weekCseTooltip below - so the
       two pop-ups on this table read as one family. */
    background-color: var(--c1);
    border-radius: var(--r2);
    box-shadow: var(--shadow-tooltip);
    box-sizing: border-box;
    color: var(--c-surface);
    font-family: var(--ff-body);
    font-weight: var(--fw1);
    line-height: 1.3;
    min-width: 132px;
    padding: 7px 9px;
    text-align: left;
    /* Beside the number rather than under it, and pinned by its top left
       corner: the number is centred in the cell, and at its widest - "100%",
       about 146px of the scoreboard face at 82px - it ends 73px right of the
       centre, so the list starts just past that and never covers it. Its top sits under
       the label, level with the number's. A longer or wider list grows right
       and down from that corner and never moves the corner itself - anchored
       by its right edge and centred on the cell, as it was, it slid left as it
       widened and rose as it lengthened. */
    left: 50%;
    transform: translateX(-50%);
    position: absolute;
    top: 100%;
    z-index: 60;
}

.weekOddsBreakdownHead{
    color: var(--c-text-muted);
    font-size: var(--fs-small3);
    letter-spacing: var(--ls1);
    margin-bottom: 5px;
    text-transform: uppercase;
    white-space: nowrap;
}

/* Shown while the number is hovered or focused, and not otherwise. No script,
   no timers: a tooltip appears when the pointer is on the thing it explains and
   goes when it leaves. Hover on an ancestor follows the DOM rather than the box,
   so pointing at the list itself keeps it up.

   .has-breakdown is added by site.js when the viewer has more than one entry. A
   single entry is its own breakdown, so there is nothing to explain. */
/* It fades in and out over 120ms. visibility goes with the opacity so that the
   list, while it cannot be seen, cannot be pointed at either - an invisible list
   that still answered the pointer would open itself whenever the pointer
   crossed the space it covers. Turned on at once when showing and only at the
   end of the fade when hiding, so neither fade is cut short. */
.weekOddsBreakdown{
    opacity: 0;
    transition: opacity 120ms linear, visibility 0s linear 120ms;
    visibility: hidden;
}

.weekOddsTracker.has-breakdown:has(.weekOddsValue:hover, .weekOddsValue:focus-visible, .weekOddsBreakdown:hover) .weekOddsBreakdown{
    opacity: 1;
    transition: opacity 120ms linear, visibility 0s linear 0s;
    visibility: visible;
}

.weekOddsBreakdownRow{
    display: flex;
    font-size: var(--fs-small3);
    gap: var(--g2);
    justify-content: space-between;
    padding: 1px 0;
    white-space: nowrap;
}

.weekOddsBreakdownName{
    color: var(--c-surface);
    overflow: hidden;
    text-overflow: ellipsis;
}

.weekOddsBreakdownOdds{
    color: var(--c-surface);
    font-weight: var(--fw3);
}

.selectMenuField:has(> #boardOddsPlace) .selectMenuButton{
      font-size: var(--fs-small4);
  }


/* ---- Moving the rows when the order changes ------------------------------
   See boardBeginReorder() in site.js. */

/* What is left once the motion is over, and what the reader looks for when they
   come back to the table. It stays until the projection changes or is cleared,
   rather than fading on a timer: the projection is a state the reader turned on,
   so its mark is too.

   The pick cells keep their own colours - the result is the thing being read -
   so only the cells around them carry the tint. */
#boardTable .boardTableRow.is-projected > td:not(.teamInTD){
    background-color: var(--c-projected-row);
}

#boardTable .boardTableRow.is-projected > td:first-child{
    box-shadow: inset 3px 0 0 var(--c2);
}

/* The viewer's own entries: a navy line down the row's left edge, as in the
   standings and the Splits tables. A strip laid over the first cell's 2px
   border rather than an inset shadow: a shadow draws inside the border, so two
   of the viewer's rows in a row would show a broken line. It reaches 1px past
   the border, to 3px. */
#boardTable .boardTableRow.user > td:first-child{
    position: relative;
}

#boardTable .boardTableRow.user > td:first-child::before{
    background: var(--c1);
    bottom: -2px;
    content: "";
    left: -2px;
    pointer-events: none;
    position: absolute;
    top: -2px;
    width: 3px;
}

/* Only the name is bold in the viewer's own rows. The row's .user class takes
   main.css's bold, which set every pick and number in the row in bold as well;
   the row goes back to the weight every other row has, and the name alone
   keeps the bold. */
#boardTable .boardTableRow.user{
    font-weight: inherit;
}

#boardTable .boardTableRow.user .boardEntryName{
    font-weight: var(--fw3);
}

/* One of the viewer's rows that is also projected keeps both marks: the
   projection's blue, a pixel wider, so 3px of it shows beside the navy. */
#boardTable .boardTableRow.user.is-projected > td:first-child{
    box-shadow: inset 4px 0 0 var(--c2);
}

/* How far the row's rank is from its rank in the standings as actually
   played: the places, after the triangle the header's spreads use
   (.spreadFavoriteMark), pointing up for better and down for worse, in the
   spreads' grey. On a long table it is what the reader relies on, rather than
   the motion, so every row whose rank differs carries one, and none does while
   the table shows only real results.

   It is written outside the table, in the margin on its left, level with its
   row: site.js puts it in the row's first cell, which is what it is placed
   against, so it moves with the row. Its right edge is a fixed distance off
   the table's, so the figures of a column of them end on one line. */
#boardTable .boardTableRow > td:first-child{
    position: relative;
}

.boardRankDelta{
    align-items: center;
    color: var(--board-ink-1);
    display: flex;
    font-family: var(--ff-body);
    font-size: var(--fs-small3);
    font-weight: var(--fw4);
    position: absolute;
    right: calc(100% + 8px);
    top: 50%;
    transform: translateY(-50%);
    white-space: nowrap;
}

/* The margin the deltas are written in. The standard Board's table fills the
   room it has, so without this it would meet the edge of the panel, which
   clips anything past it; padding both sides keeps the table centred, and a
   narrow window takes the room from the names' column, as it does the rest
   of the table's slack. The Pick 5 Board shows no deltas: it has nothing to
   project or override. */
#boardPage:not(.boardPage--pick5){
    padding-inline: 32px;
}

.boardRankDelta--up > .spreadFavoriteMark{
    transform: rotate(-90deg);
}

.boardRankDelta--down > .spreadFavoriteMark{
    transform: rotate(-270deg);
}

/* Where the viewer's entry went, when a change leaves it out of sight - "You:
   210th (−170)" - floating over the foot of the window, centred on the table
   (site.js sets its left). A click scrolls to the entry. */
.boardYouChip{
    background: var(--c1);
    border: 0;
    border-radius: 999px;
    bottom: 24px;
    box-shadow: var(--shadow-fab);
    color: var(--c-surface);
    cursor: pointer;
    font-family: var(--ff-body);
    font-size: var(--fs-small1);
    font-weight: var(--fw3);
    padding: 8px 16px;
    position: fixed;
    transform: translateX(-50%);
    white-space: nowrap;
    z-index: 300;
}

.boardYouChip:focus-visible{
    outline: 2px solid var(--c2);
    outline-offset: 2px;
}

.separator{
    font-family: var(--ff-body);
    font-size: 9pt;
    color: var(--c-text-primary);
    float: right;
    margin: 0 4px 0 4px;
}

/* Sized by #boardPage above: one rule for every page width, so there are
   no container steps to keep in line with the column counts, which change from
   week to week. The literals are only fallbacks for a page that does not
   publish the properties; change the widths in board.php. */
#boardTable{
    width: var(--board-live-width);
    --width-rank: var(--board-rank-fit-width, 20px);
    --width-name: var(--board-name-width);
    --width-wand: var(--board-wand-width, 32px);
    --width-game: var(--board-fixed-col-width, 36px);
    --width-stat: var(--board-stat-col-width, 48px);
    
    /* The game header's full height: .atsHeaderContainer's 93px and its 6px
       margin above and below. The Week/Season and Wins/CSE rows each take
       half; were it short of the real height, Safari would give the whole
       difference to the lower row and the rule between them would sit above
       the spreads' middle. */
    --board-game-header-height: 105px;
    --board-game-header-midpoint: calc(var(--board-game-header-height) / 2);
    
    border-collapse: separate;
    /* Zero on purpose: the gaps between cells are the cells' own transparent
       borders (see .boardTableRow > td), so a projected row's tint runs under
       them and reads as one band. Spacing here would be the table's, and would
       break that band into tiles. */
    border-spacing: 0;
    margin-left: auto;
    margin-right: auto;
    padding-top: 5px;
    table-layout: fixed;
    font-family: var(--ff-body);
    font-size: var(--fs-body);
}

/* The pick5 table is the one tracker whose width is a pixel total rather than a
   share of the viewport - board.php sizes it, and the search bar and tool
   row above it, from $boardPick5TableWidth. Its columns are therefore stated
   in the same pixels that make up that total, so nothing is left over for Chrome
   and Safari to place differently. Every width below comes from board.php
   rather than from a number kept here: the rank and pick/stat columns read the
   pixel weights it publishes, and the name column is $boardPick5NameColumnWidth,
   published as both the widest and the narrowest it may be. Editing a width in
   this file instead of in the PHP is what pulls the columns out of step with the
   table, so change the PHP constants and let these follow. */
#boardTable.pick5BoardTable{
    --board-game-header-height: 56px;
    --width-rank: var(--board-rank-fit-width, 20px);
    --width-game: var(--board-fixed-col-width, 36px);
    --width-stat: var(--board-stat-col-width, 48px);
    margin-left: auto;
    margin-right: auto;
    table-layout: fixed;
}

.pick5BoardTable th{
    border-bottom: 1px solid var(--c1);
    padding: 8px 6px;
    text-align: center;
    white-space: nowrap;
}

/* Room between the header's rule and the first row, so the first row's pills
   sit as far below the rule as each row's pills sit below the row above. The
   pills take a row's whole height inside their insets whatever the avatars'
   size (see "A row's geometry" at the top of this file), so the room over a
   first-row pill is always one cell edge, and this adds one more. A pick-all
   table has its percentages row there instead, which makes the same room under
   its rule (#comparisonSummaryRow). */
#boardTable.pick5BoardTable{
    --pick5-first-row-gap: var(--board-cell-edge);
}

#boardTable.pick5BoardTable tbody::before{
    content: "";
    display: table-row;
    height: var(--pick5-first-row-gap);
}

/* And under the last row, whichever row sorting or searching leaves there. */
#boardTable tbody::after{
    content: "";
    display: table-row;
    height: var(--board-cell-edge);
}

.pick5RankHeader,
.pick5RankCell{
    text-align: center;
    width: var(--width-rank);
}

.pick5RankHeader,
.pick5EntryHeader,
.pick5PickHeader{
    vertical-align: middle;
}

.pick5BoardTable .boardHeaders{
    padding-bottom: 0;
}

.pick5EntryHeader,
.pick5EntryName{
    width: var(--width-name);
}

.pick5PickHeader{
    width: 300px;
}

.pick5PickCell{
    width:var(--width-game);
}

.boardRankCol,
.pick5RankCol{
    width: var(--width-rank);
}

.boardNameCol,
.pick5EntryCol{
    width: var(--width-name);
}

.boardEntryCheckCol{
    width: var(--width-wand);
}

.boardGameCol,
.pick5PickCol{
    width:var(--width-game);
}

.boardStatCol,
.pick5StatCol{
    width:var(--width-stat);
}

.boardEntryName,
#boardTeamHeader{
    position: relative;
    text-align: left;
    vertical-align: top;
    padding-left: 0;
}

/* The name sits in the row's middle, as the rank and the pick pills do; top
   alignment left it riding high once the pills gave the row its height. */
.boardEntryName{
    vertical-align: middle;
}

#boardTable .boardEntryName{
    box-sizing: border-box;
    font-weight: var(--fw2);
    max-width: var(--width-name);
    overflow: visible;
    position: relative;
    text-overflow: ellipsis;
    width: var(--width-name);
    white-space: nowrap;
}

#boardTable .boardEntryName:has(.entryProfileLink:hover),
#boardTable .boardEntryName:has(.entryProfileName:hover),
#boardTable .boardEntryName:has(.entryProfileLink:focus-visible){
    z-index: 20;
}

#boardTable .boardEntryName .entryProfileContent{
    /* A block-level flex box, not the inline one main.css makes it: inline, it
       is lined up against the text baseline, which left the name a fraction of
       a pixel below the rank beside it. As a block it is centred in the cell
       the way the rank's own line is, so the two lines share a middle. */
    display: flex;
    width: 100%;
}

#boardTable .boardRankCell,
#boardTable .pick5RankHeader,
#boardTable .pick5RankCell{
    box-sizing: border-box;
    max-width: var(--width-rank);
    min-width: var(--width-rank);
    padding-right: 4px;
    text-align: right;
    width: var(--width-rank);
}

#boardTable .pick5RankHeader{
    padding-left: 0;
}

#boardTable:not(.pick5BoardTable) .boardEntryName{
    width: var(--width-name);
}

.boardEntryCheckHeader{
    box-sizing: border-box;
    overflow: visible;
    padding: 0;
    position: relative;
    text-align: center;
    vertical-align: bottom;
    width: 32px;
}

.boardEntryCheckCell{
    box-sizing: border-box;
    font-size: var(--fs-small1);
    padding: 0;
    text-align: center;
    vertical-align: middle;
}

.boardPPButton{
    display: flex;
    align-items: center;
    justify-content: center;
    border: none;
    background: transparent;
    border-radius: var(--r2);   
    color: var(--c-text-muted);
    height: 100%;
    width: 100%;
    transform: translateY(1.5px);
    transition: color 120ms linear, transform 120ms linear;
    /* Out of sight until the pointer is on its row, and then only that row's
       shows - or while it has the keyboard's focus. Transparent rather than
       hidden, so it keeps its place and can still be tabbed to. */
    opacity: 0;
}

.boardTableRow:hover .boardPPButton,
.boardPPButton:focus-visible{
    opacity: 1;
}

/* Hidden rather than removed: the script brings it back without a reload.
   visibility keeps the cell's width, so the column does not collapse and the
   row does not reflow as the button comes and goes. */
.boardPPButton--hidden{
    visibility: hidden;
    pointer-events: none;
}

.boardPPButton:hover{
    color: var(--c1) !important;
    cursor: pointer;
    transform: translateY(1.5px) scale(1.2);
}

/* The wand of the row being projected stays lit, whatever the pointer does:
   as it is under the pointer while every undecided pick in its row is
   projected to win, and at half strength while only some are - see
   refreshBoardWandStates() in site.js. */
#boardTable .boardPPButton.is-projectingAll,
#boardTable .boardPPButton.is-projectingSome{
    color: var(--c-text-primary);
    cursor: pointer;
    transform: translateY(1.5px) scale(1.2);
    opacity: 1;
}

#boardTable .boardPPButton.is-projectingSome{
    opacity: .5;
}

.atsHeader{
    text-align: center;
    align-content: center;
    margin: 0 auto;
    position: relative;
    
    width:var(--width-game);  
    height: var(--board-game-header-height);
    box-sizing: border-box;
    cursor: default;
    padding: 0;
    vertical-align: top;
}

/* A kickoff window's colour, on the game's header cell rather than its
   .atsHeaderContainer, so it fills the cell's full height - the container's
   margins included - as the rule between games (.atsHeader::before) does. */
.boardHeaderGroupAlt{
    background-color: var(--c1-n4);
}

/* Three rows: the top team's code, the spread, and the bottom team's code. The
   12px of padding above and below holds each code's score - the top team's over
   its code, the bottom team's under it; see "Scores above and below the team
   codes" near the end of this file. */
.atsHeaderContainer{
    display: grid;
    grid-template-rows: 25px 19px 25px;
    width: 100%;
    height: 93px;
    padding: 12px 0;
    box-sizing: border-box;
    overflow: hidden;
    position: relative;
    margin: 6px 0;
}

/* Straight-up leagues print no spread, so its 19px row is dropped and the stack
   closes up rather than holding an empty band in the middle of the matchup.

   The element is hidden rather than omitted from the markup: the container's
   children are addressed by :nth-child elsewhere in this file, and removing one
   would renumber the rest. display:none keeps it out of the grid's flow while
   leaving those indices alone.

   --board-game-header-height moves with it: the container's 74px and its 6px
   margins. The Week/Season group header and the Wins/CSE detail header split
   that value between them, so leaving it at 105px would leave those two rows
   19px taller than the game columns they sit beside, and the two halves of the
   header would stop lining up. */
#boardTable.boardTable--noSpreads {
    --board-game-header-height: 86px;
}

.boardTable--noSpreads .atsHeaderContainer {
    grid-template-rows: 25px 25px;
    height: 74px;
}

.boardTable--noSpreads .spreadInATSheader {
    display: none;
}

.boardHeaders{
    text-align: center;
    vertical-align: bottom;
    padding-bottom: 25px; /* centers vertically */
}

.boardTableGroupHeader{
    position: relative;
    text-align: center;
    vertical-align: bottom;
    height: var(--board-game-header-midpoint);
    padding: 0;
}

.boardTableGroupHeader::after{
    content: "";
    position: absolute;
    left: 0;
    right: 0;
    bottom: -1px;
    height: 1px;
    background: black;
    z-index: 1;
}

.boardTableGroupRow .boardTableGroupHeader:nth-last-child(2)::after{
    left: 5%;
    right: 0;
}

.boardTableGroupRow .boardTableGroupHeader:last-child::after{
    left: 0;
    right: 5%;
}

#boardTable:not(.pick5BoardTable) .boardTableGroupHeader{
    border-bottom: 0;
    padding: 0 6px;
}

/* The rule centred on the edge between the two header rows, which is the
   spreads' middle. */
#boardTable:not(.pick5BoardTable) .boardTableGroupHeader::after{
    bottom: -.5px;
}

/* Week and Season ride 6px above where the cell would put them, so the space
   between the label and the rule under it matches the space between that rule
   and the Wins/CSE labels below: 11px of clear pixels either side, measured off
   the ink rather than off the boxes, because a descender below and a cap height
   above do not sit the same distance inside their line boxes.

   A relative shift rather than padding on the cell. The two header rows split
   --board-game-header-height between them, and the game columns beside them
   are one cell of exactly that height, so anything that changes this cell's box
   stretches the header and leaves the game columns 6px short of its baseline.
   Shifting the label paints it elsewhere without resizing anything. */
#boardTable:not(.pick5BoardTable) .boardTableGroupHeader .boardTableHeaderLabel{
    position: relative;
    top: -6px;
}

/* The Wins and CSE cells would hold their labels on a line as tall as the
   table's body text, which with their padding came to 38px - more than half
   the header, so the row grew and took the header past its height. A line of
   their own labels' height leaves them under half. */
#boardTable:not(.pick5BoardTable) .boardTableDetailHeader{
    line-height: 1;
}

/* Wins and CSE ride 1.5px above where their cell puts them, so they sit as far
   under the Week/Season rule as Week and Season sit over it - 10px of clear
   pixels either side, measured off the ink. That centres the whole block on the
   header, whose middle the rule already marks. A relative shift, for the same
   reason as the one above: the cell's box has to stay the size it is. */
#boardTable:not(.pick5BoardTable) .boardTableDetailHeader .boardTableHeaderLabel{
    position: relative;
    top: -1.5px;
}

#boardTable.pick5BoardTable .boardTableGroupHeader{
    border-bottom: 0;
    padding: 8px 6px;
    vertical-align: bottom;
}

#boardTable:not(.pick5BoardTable) .boardTableDetailHeader{
    padding: 8px 6px;
}

#boardTable.pick5BoardTable .boardTableDetailHeader{
    padding: 8px 6px;
}

#boardTable.pick5BoardTable .boardTableDetailHeader.tb2{
    border-right: 0;
}

.boardTableGroupHeader:last-child{
    border-right: 0;
    border-bottom: 0;
}

.boardTableDetailHeader{
    text-align: center;
    vertical-align: top;
    height: var(--board-game-header-midpoint);
    padding: 0;
}

.boardTableHeaderLabel{
    display: inline-block;
    line-height: 1;
}

#boardTeamHeader{
    box-sizing: border-box;
}

/* The 4px gap around the team code is a margin, not a border.

   It used to be a border painted the colour of whatever sat behind it - the page
   for a default group, --c1-n4 for an alternate one, --c1-n6 while the group was
   hovered - which took two more rules to keep in step and still left the border
   box, the thing border-radius rounds, outside the fill. The rounding therefore
   landed on an edge nobody could see, and the fill kept the padding box's corner
   radius: the outer radius less the 4px border, which at --r1 is nothing at all.

   As a margin the gap is the container showing through, so it follows the group
   colour on its own, and the element's border box is the fill itself - which is
   what the radius below now rounds. The grid stretches the item into the space
   the margin leaves, so the fill keeps exactly the size the border gave it and
   width: 100% has to go: with a margin it would measure the full column and push
   the item 8px wider than its row. */
.teamInATSheader{
    display: flex;
    align-items: center;
    justify-content: center;
    text-align: center;
    min-height: 0;
    box-sizing: border-box;
    margin: 4px;
    padding: 0 1px;
    line-height: 1;
    /* Default until the header is actually good for something. Only a locked
       game with no result yet can be projected, so only that one offers a
       pointer - see .tbd below. A finished game and a game that has not locked
       both answer nothing, and neither should invite the click. */
    cursor: default;
    border-radius: var(--r1);
    outline: 1px solid transparent;
    outline-offset: -1px;
    transition: outline 60ms linear;
}

/* Each code 2px nearer the spread than the middle of its row: the top
   code's margin is 6px above it and 2px below, the bottom code's 2px above
   and 6px below. A code's score hangs off its box, so it moves with it. */
.teamInATSheader:first-child{
    margin-top: 6px;
    margin-bottom: 2px;
}

.teamInATSheader:last-child{
    margin-top: 2px;
    margin-bottom: 6px;
}

.spreadInATSheader{
    display: flex;
    align-items: center;
    justify-content: center;
    width: 100%;
    min-height: 0;
    box-sizing: border-box;
    margin: 0;
    line-height: 1;
}

/* Locked, undecided, results showing: the one state a click can do something
   with while the table is reporting results. */
.teamInATSheader.tbd{
    cursor: pointer;
}

/* Under the pointer it takes the projected winner's look - the click would
   make it one. See .teamInATSheader.simCovered. */

/* Away codes read lowercase against the home codes' uppercase - the convention
   the tracker has always used. It is settled here rather than in PHP: the code
   is uppercase in the markup. */
.away{
    text-transform: lowercase;
}

.pick5PickCell.away,
.pick5PickCell.home{
    text-transform: uppercase;
}

/* --- The hovered pick grows, in both tables and the pick history
   modal --------------------------------------------------------------------
   The cell scales up on its own transition (see .teamInTD). Raised above its
   neighbours so the cells painted after it do not cover its edges. */
.teamInTD:hover{
    position: relative;
    z-index: 1;
    transform: translateY(-1px);
}

.boardTableNumberHeaders{
    text-align: center;
    width:var(--width-game);
    font-size: var(--fs-body);
    box-sizing: border-box;
    padding: inherit 0;
}

.pick5BoardTable .boardTableNumberHeaders,
.pick5BoardTable .boardTableNumbers{
    width:var(--width-game);
}

.boardTableNumberHeaders.noSort{
    cursor: default;   
}

.boardTableNumbers{
    text-align: center;
    border: transparent;
    width:var(--width-game);
}

.covered{
    background-color: var(--c-win);
    color: var(--c-win-text);
}

/* Both codes carry .xpush when a game pushes or ties - board.php sets it
   for either result, the same way both scores turn .tie - so the pair colours
   together and neither reads as having beaten the other. */
.xpush{
    background-color: var(--c-push);
    color: var(--c-push-text);
}

.test{
    width: 100px;
    text-align: center;
    align-content: center;
    background-color: blue;
}

/* A selection's pill, graded and ungraded. These rules are the one place a
   selection is drawn: the Board's rows and the pick history modal
   (#pickHistoryModal, its cells .modalPickHistoryCell) both wear them, so a
   change here shows in both. The Overview's My Picks card draws its picks
   its own way (overview.css). None of them is scoped to the Board's table.

   The result colour lives on .teamInTDFill inside the cell, which carries the
   rounding. The 2px padding, with the cell's 2px border, sets the pill 4px in
   from the column's edges. The Pick 5 distribution modal's teams are these
   cells too (.modalDistributionCard). The type is stated here rather than
   left to the table around the cell, so a cell reads the same wherever it is
   set. The pill's height is named once, here, for every cell and for the
   Board's row geometry, which never makes a pill shorter than it (see "A
   row's geometry" above). */
.teamInTD{
    box-sizing: border-box;
    border: var(--board-cell-border) solid transparent;
    padding: var(--board-pick-inset);
    width: var(--board-fixed-col-width);
    text-align: center;
    color: var(--c-text-primary);
    font-family: var(--ff-body);
    font-size: var(--fs-body);
    transition: transform 120ms linear;
    font-weight: 500;
}

/* A cell out of the Board's table. */
span.teamInTD{
    display: block;
}

.teamInTDFill{
    /* A flex box so whatever it holds - a team, the dash, the eye-slash - sits
       in its vertical middle, and across its middle as the cell's centred text
       did. */
    display: flex;
    align-items: center;
    justify-content: center;
    border-radius: var(--r1);
    height: var(--pick-pill-height);
}

/* On the Board, a pick's colours - its fill, its ink, and its outline - change
   over a short transition when a projection or an override is made or taken
   off. A result or a kickoff that arrives while the Board is open fades in
   over longer, and site.js sets this transition aside for that fade (see
   "Results that arrive while the Board is open"). */
#boardTable .teamInTDFill{
    transition: background-color 60ms linear, color 60ms linear, outline-color 60ms linear;
}

/* A pick never made, as the m-site and app show it: a gray pill with an en
   dash; a pick made but still hidden takes the same pill with an eye-slash in
   place of the dash. The dash is drawn here rather than written into the cell,
   so the cell's text stays empty for the scripts that read a pick from it. */
.teamInTDFill:empty,
.teamInTDFill--hidden{
    font-size: var(--fs-small4);
}

.teamInTDFill:empty::before{
    content: "\2013";
}

.correct > .teamInTDFill{
    background-color: var(--c-win);
    color: var(--c-win-text);
}

/* A projected result, on trial: no fill, its text and a solid line just
   inside its edge in the projection colours, --c-win-proj and --c-loss-proj
   (the line is in the shared rule below, "The projection look"). The hatching
   it replaces is kept below, to go back to. */
/* A team the projection has covering, in the header, takes the same look as a
   projected win below it - and so does a team a click would project, under
   the pointer. */
.simCorrect > .teamInTDFill,
.teamInATSheader.simCovered,
.teamInATSheader.tbd:not(.is-hoverSuppressed):hover{
    background: transparent;
    color: var(--c-win-proj);
    /* background-image: repeating-linear-gradient(
        45deg,
        var(--c-win),
        var(--c-win) 5px,
        white 5px,
        white 6px
    ); */
}

.incorrect > .teamInTDFill{
    background-color: var(--c-loss);
    color: var(--c-loss-text);
}

.simIncorrect > .teamInTDFill{
    background: transparent;
    color: var(--c-loss-proj);
    /* background-image: repeating-linear-gradient(
        45deg,
        var(--c-loss),
        var(--c-loss) 5px,
        white 5px,
        white 6px
    ); */
}

/* The projection look, in one place for all three things that wear it: a
   header team that a click would project (.tbd under the pointer), and a
   projected result - a pick projected to win and the team projected to cover
   in the header, and a pick projected to lose. Each keeps its own fill and ink
   in its own rule; this is what they share, so changing it here changes all
   three. */
.tbd:not(.is-hoverSuppressed):hover,
.simCorrect > .teamInTDFill,
.teamInATSheader.simCovered,
.simIncorrect > .teamInTDFill{
    outline: 1px solid currentColor;
    outline-offset: -1px;
}

/* While anything is projected or overridden, the CSE columns - both figures
   and their headers - are set back at half strength: the points answer the
   projection and the CSE does not (see syncBoardTable() in site.js), so the
   column that is not playing along steps out of the way. */
#boardTable:has(.simCorrect, .simIncorrect, .simCovered, .resultOverride) :is(.boardCseHeader, td.currentWeekCse, td.seasonCse){
    opacity: .5;
}

/* A finished game played the other way from the header - see "Overriding a
   finished game" in site.js. The flipped result swaps its fill and ink: the
   win's or the loss's text colour as the ground, and its fill colour as the
   text. */
.resultOverride.correct > .teamInTDFill{
    background-color: var(--c-win-text);
    color: var(--c-win);
}

.resultOverride.incorrect > .teamInTDFill{
    background-color: var(--c-loss-text);
    color: var(--c-loss);
}

/* A pushed or tied game played one way from the header. site.js counts it as
   a projection (.simCorrect and .simIncorrect over .push), but it is a
   finished game, so it is drawn as an overridden one is: the picks on the
   team clicked as overridden wins, the rest as overridden losses. */
.push.simCorrect > .teamInTDFill{
    background-color: var(--c-win-text);
    color: var(--c-win);
    outline: none;
}

.push.simIncorrect > .teamInTDFill{
    background-color: var(--c-loss-text);
    color: var(--c-loss);
    outline: none;
}

/* The team that lost a finished game answers a click, which overrides the
   result. */
.atsHeaderContainer:has(.teamInATSheader.covered) .teamInATSheader:not(.covered){
    cursor: pointer;
}

/* An overridden game in the header: the real winner gives up the win's fill and
   ink, and the real loser takes them swapped - the win's ink as its ground and
   its fill as the text - as the picks below do. The classes stay where the result put them - .covered still marks
   the real winner, which is how a second click knows to put the result back -
   so the swap is drawn here, keyed on .is-resultOverridden. The loser looks
   the same under the pointer before the click, as a preview of it. */
#boardTable .atsHeaderContainer.is-resultOverridden .teamInATSheader.covered{
    background: none;
    color: var(--board-ink-1);
}

#boardTable .atsHeaderContainer.is-resultOverridden .teamInATSheader:not(.covered),
#boardTable .atsHeaderContainer:has(.teamInATSheader.covered):not(.is-resultOverridden) .teamInATSheader:not(.covered):not(.is-hoverSuppressed):hover{
    background-color: var(--c-win-text);
    color: var(--c-win);
}

/* An overridden game under the pointer on its overridden loser - the team now
   shown as the winner - looks as a click would leave it, with the result put
   back: the loser plain again, and the real winner in the win's fill and ink.
   As with the projections, not on a team just clicked until the pointer
   leaves it (.is-hoverSuppressed, from site.js). */
#boardTable .atsHeaderContainer.is-resultOverridden .teamInATSheader:not(.covered):not(.is-hoverSuppressed):hover{
    background: none;
    color: var(--board-ink-1);
}

#boardTable .atsHeaderContainer.is-resultOverridden:has(.teamInATSheader:not(.covered):not(.is-hoverSuppressed):hover) .teamInATSheader.covered{
    background-color: var(--c-win);
    color: var(--c-win-text);
}

/* A pushed or tied game in the header, played the same way: either team
   answers a click, and the team clicked (.simCovered, from site.js) takes the
   overridden winner's look while the other goes plain, as the real winner of
   an overridden game does. Under the pointer, each previews its click, as on
   any other finished game: an untouched team the overridden winner's look,
   the team clicked both teams back to the push, and the other team the
   overridden winner's look with the clicked one plain. */
.teamInATSheader.xpush{
    cursor: pointer;
}

#boardTable .atsHeaderContainer .teamInATSheader.xpush.simCovered,
#boardTable .atsHeaderContainer:not(:has(.simCovered)) .teamInATSheader.xpush:not(.is-hoverSuppressed):hover,
#boardTable .atsHeaderContainer:has(.xpush.simCovered) .teamInATSheader.xpush:not(.simCovered):not(.is-hoverSuppressed):hover{
    background-color: var(--c-win-text);
    color: var(--c-win);
    outline: none;
}

#boardTable .atsHeaderContainer:has(.xpush.simCovered) .teamInATSheader.xpush:not(.simCovered),
#boardTable .atsHeaderContainer:has(.xpush:not(.simCovered):not(.is-hoverSuppressed):hover) .teamInATSheader.xpush.simCovered{
    background: none;
    color: var(--board-ink-1);
    outline: none;
}

#boardTable .atsHeaderContainer .teamInATSheader.xpush.simCovered:not(.is-hoverSuppressed):hover,
#boardTable .atsHeaderContainer:has(.xpush.simCovered:not(.is-hoverSuppressed):hover) .teamInATSheader.xpush:not(.simCovered){
    background-color: var(--c-push);
    color: var(--c-push-text);
    outline: none;
}

.push > .teamInTDFill{
    background-color: var(--c-push);
    color: var(--c-push-text);
}

/* Color blind mode - the universal-access button in the page hero (see
   dashboard.js) - on the Board's cells: the team in Oswald, with a glyph
   beside it that says the result in a shape as well as a colour, the two
   centred in the cell as one. A loss, finished or projected, has its glyph
   before the team; every other result has it after. A finished game's
   result takes a check in a filled square for a win, a cross in a filled
   square for a loss, and an equals sign for a push or a tie - and that holds for
   an overridden result too, and for a push played one way from the header,
   since those games are finished. A projected result on a game still to play
   takes a bare check or cross. A game still to play with nothing
   projected, a pick never made, and a pick still hidden take no glyph. The
   glyphs are Font Awesome's own, drawn from its fonts the way its classes
   draw them: fa-solid fa-square-check, fa-solid fa-square-xmark, fa-solid
   fa-equals, fa-solid fa-check, and fa-solid fa-xmark. The pick history
   modal's cells (#pickHistoryBody) and the Pick 5 distribution modal's
   (#boardDistributionModal) take them too, as they take the Board's other
   looks, and the color blind legend (.modalLegend--colorblind, in the
   Board's help modal) wears the same cells whatever the mode, so all three
   are named beside #boardTable in each rule. */
/* The sizes of a color blind cell's team and of its glyph, each set on its
   own, and only in color blind mode - the header's teams and glyphs take them
   too. */
:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind){
    --board-colorblind-text-size: var(--fs-small1);
    --board-colorblind-glyph-size: var(--fs-small3);
    /* How far a result's glyph sits in from the pill's edge - see the grid
       below. A wider inset narrows the team's column, and WSH, the widest
       code, then comes closer to its glyph: at 5px in a 44px pill it is 2.3px
       from it. */
    --board-colorblind-glyph-inset: 5px;
}

/* Not on a pick still hidden: its eye-slash keeps the size it has outside
   color blind mode (.teamInTDFill--hidden). */
:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) .teamInTD > .teamInTDFill:not(.teamInTDFill--hidden){
    font-size: var(--board-colorblind-text-size);
    font-family: "Oswald", var(--ff-body);
    font-weight: var(--fw1);
    justify-content: center;
    gap: .3em;
    padding: 0 6px;
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) :is(.correct, .incorrect, .push, .simCorrect, .simIncorrect) > .teamInTDFill:not(:empty, .teamInTDFill--hidden)::after{
    font: var(--fa-font-solid);
    font-size: var(--board-colorblind-glyph-size);
    -webkit-font-smoothing: antialiased;
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) :is(.correct, .push.simCorrect) > .teamInTDFill:not(:empty, .teamInTDFill--hidden)::after{
    content: "\f14a";
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) :is(.incorrect, .push.simIncorrect) > .teamInTDFill:not(:empty, .teamInTDFill--hidden)::after{
    content: "\f2d3";
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) .push:not(.simCorrect, .simIncorrect) > .teamInTDFill:not(:empty, .teamInTDFill--hidden)::after{
    content: "\f52c";
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) .simCorrect:not(.push) > .teamInTDFill:not(:empty, .teamInTDFill--hidden)::after{
    content: "\f00c";
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) .simIncorrect:not(.push) > .teamInTDFill:not(:empty, .teamInTDFill--hidden)::after{
    content: "\f00d";
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) :is(.incorrect, .push.simIncorrect, .simIncorrect:not(.push)) > .teamInTDFill:not(:empty, .teamInTDFill--hidden)::after{
    order: -1;
}

/* A cell with a glyph sets the team and the glyph in a grid of two columns
   across the pill's width inside its padding: the glyph's, against the
   padding, so every glyph sits --board-colorblind-glyph-inset in from the
   pill's edge - after the team for a win or a push, before it for a loss -
   and the team's, which takes the rest, the code centred in it. So the
   glyphs line up down a column whatever the codes beside them. A code wider
   than its column (WSH is the widest) spills out of it evenly on both
   sides. */
:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) :is(.correct, .incorrect, .push, .simCorrect, .simIncorrect) > .teamInTDFill:not(:empty, .teamInTDFill--hidden){
    align-items: center;
    display: grid;
    padding-inline: var(--board-colorblind-glyph-inset);
    grid-auto-flow: column;
    grid-template-columns: minmax(0, 1fr) auto;
    justify-items: center;
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) :is(.incorrect, .push.simIncorrect, .simIncorrect:not(.push)) > .teamInTDFill:not(:empty, .teamInTDFill--hidden){
    grid-template-columns: auto minmax(0, 1fr);
}

/* The team centred up and down on its letters rather than on its line box,
   which in Oswald sits its letters low: an uppercase code on its cap height,
   a lowercase one on its x-height. The cell's bottom padding lifts the team
   and its glyph by half of it, and the glyph, already centred, is set back
   down by the same. The offsets are Oswald's: the middle of its line box sits
   0.045em above the middle of its caps and 0.161em above the middle of its
   x-height, taken of the team's size so the glyph, at a size of its own, is
   set back down by the same length. */
:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) .teamInTD > .teamInTDFill:not(:empty, .teamInTDFill--hidden){
    --board-colorblind-pick-lift: calc(.045 * var(--board-colorblind-text-size));
    box-sizing: border-box;
    padding-bottom: calc(2 * var(--board-colorblind-pick-lift));
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) .teamInTD.away:not(.pick5PickCell) > .teamInTDFill:not(:empty, .teamInTDFill--hidden){
    --board-colorblind-pick-lift: calc(.161 * var(--board-colorblind-text-size));
}

:is(.is-colorblindMode #boardTable, .is-colorblindMode #pickHistoryBody, .is-colorblindMode #boardDistributionModal, .modalLegend--colorblind) .teamInTD > .teamInTDFill:not(:empty, .teamInTDFill--hidden)::after{
    position: relative;
    top: var(--board-colorblind-pick-lift);
}

/* Every team in the header in color blind mode takes the picks' type: Oswald
   at the picks' size and weight, with the same lift to centre it on its
   letters. */
.is-colorblindMode #boardTable .atsHeaderContainer .teamInATSheader{
    --board-colorblind-pick-lift: calc(.045 * var(--board-colorblind-text-size));
    font-family: "Oswald", var(--ff-body);
    font-size: var(--board-colorblind-text-size);
    font-weight: var(--fw1);
    letter-spacing: normal;
    gap: .3em;
    padding-bottom: calc(2 * var(--board-colorblind-pick-lift));
}

.is-colorblindMode #boardTable .atsHeaderContainer .teamInATSheader.away{
    --board-colorblind-pick-lift: calc(.161 * var(--board-colorblind-text-size));
}

/* The header's winners take the winning picks' glyph after the team as well.
   A finished game's winner takes the square check - the real winner, and the
   new winner of an overridden game or of a push or tie played one way from
   the header - and a projected winner the bare check. Each follows its look
   rather than its class: a team that shows a winner's fill only as a preview
   under the pointer takes the glyph too, and a winner whose preview shows it
   plain gives the glyph up, so the glyph never disagrees with the fill. The
   glyph is ::before, set after the team by order, because ::after holds the
   score. */
.is-colorblindMode #boardTable .atsHeaderContainer:not(.is-resultOverridden) .teamInATSheader.covered::before,
.is-colorblindMode #boardTable .atsHeaderContainer.is-resultOverridden:has(.teamInATSheader:not(.covered):not(.is-hoverSuppressed):hover) .teamInATSheader.covered::before,
.is-colorblindMode #boardTable .atsHeaderContainer.is-resultOverridden .teamInATSheader:not(.covered):is(.is-hoverSuppressed, :not(:hover))::before,
.is-colorblindMode #boardTable .atsHeaderContainer:has(.teamInATSheader.covered):not(.is-resultOverridden) .teamInATSheader:not(.covered):not(.is-hoverSuppressed):hover::before,
.is-colorblindMode #boardTable .atsHeaderContainer .teamInATSheader.xpush.simCovered:is(.is-hoverSuppressed, :not(:hover))::before,
.is-colorblindMode #boardTable .atsHeaderContainer:not(:has(.simCovered)) .teamInATSheader.xpush:not(.is-hoverSuppressed):hover::before,
.is-colorblindMode #boardTable .atsHeaderContainer:has(.xpush.simCovered) .teamInATSheader.xpush:not(.simCovered):not(.is-hoverSuppressed):hover::before,
.is-colorblindMode #boardTable .atsHeaderContainer .teamInATSheader.simCovered:not(.xpush):is(.is-hoverSuppressed, :not(:hover))::before,
.is-colorblindMode #boardTable .atsHeaderContainer .teamInATSheader.tbd:not(.simCovered):not(.is-hoverSuppressed):hover::before{
    content: "\f14a";
    font: var(--fa-font-solid);
    font-size: var(--board-colorblind-glyph-size);
    -webkit-font-smoothing: antialiased;
    order: 1;
    position: relative;
    top: var(--board-colorblind-pick-lift);
}

.is-colorblindMode #boardTable .atsHeaderContainer .teamInATSheader.simCovered:not(.xpush):is(.is-hoverSuppressed, :not(:hover))::before,
.is-colorblindMode #boardTable .atsHeaderContainer .teamInATSheader.tbd:not(.simCovered):not(.is-hoverSuppressed):hover::before{
    content: "\f00c";
}

/* Points that are not the week as played, in italics, as the projected picks
   behind them are: a row's week and season points while any of its picks is
   a projected result, or a finished game's result overridden from the header. */
#boardTable .boardTableRow:has(.resultOverride) > td.currentWeekWinCount,
#boardTable .boardTableRow:has(.resultOverride) > td.boardOddsCell,
#boardTable .boardTableRow:has(.resultOverride) > td.seasonWinCount,
#boardTable .boardTableRow:has(.simCorrect, .simIncorrect) > td.currentWeekWinCount,
#boardTable .boardTableRow:has(.simCorrect, .simIncorrect) > td.boardOddsCell,
#boardTable .boardTableRow:has(.simCorrect, .simIncorrect) > td.seasonWinCount{
    font-style: italic;
}

/* Anything not yet a win, a loss, or a push - a game still to finish, a pick
   still hidden or missing - on the pale ink, on the Board and in the entry
   picks modal alike. A projected result has its own look, so it is excluded
   not by name here but by the classes that mark it. */
.teamInTDFill:empty,
.teamInTDFill--hidden,
.teamInTD:not(.correct, .incorrect, .push, .simCorrect, .simIncorrect) > .teamInTDFill{
    background-color: var(--c2-n4);
    color: var(--c2-n9);
}

/* A game under way but not yet final (.inProgress, set in board.php). A
   projected result keeps its own look. */
.teamInTD.inProgress:not(.correct, .incorrect, .push, .simCorrect, .simIncorrect) > .teamInTDFill{
    background-color: var(--c2-n4);
    color: var(--c2-n9);
    outline: 1px solid currentColor;
    outline-offset: -1px;
}

.outline{
    border: 1px solid var(--c-push);
}

.boardTooltip{
    position: absolute;
    top: 0;
    left: 50%;
    transform: translateX(-50%);
    visibility: hidden;
    z-index: 9999;
    
    font-family: var(--ff-body);
    font-size: var(--fs-small3);
    text-align: center;
    padding: 2px;
    white-space: nowrap;
    
    background-color: var(--c1);
    color: var(--c-surface);
    border-radius: var(--r2);
}

/* A row does nothing under the pointer: no hover state, and the arrow rather
   than the text cursor over its figures and names. */
.boardTableRow{
    cursor: default;
}

/* Every body cell keeps 2px clear on each side - the gap between the pills, and
   the inset the rank, the name, and the figures are set from. Transparent, so a
   projected row's tint runs under it. */
.boardTableRow > td{
    border: 2px solid transparent;
    box-sizing: border-box;
}

.big{
    display: table-cell;
    vertical-align: bottom;
    position: absolute;
    cursor: default;
}

/* --- The rule before the Season columns -------------------------------------
   The Season columns are set off from the Week columns by one vertical rule down
   their left edge, from the top of the header to the last entry, in the colour
   of the rules between the games. Each cell on that edge draws its own piece:
   the Season label, the Wins label under it, and the first season cell of every
   body row (.tb straight after a cell that is not one). Each piece reaches over
   the cell's border to the column's outer edge and across the top and bottom
   borders to meet the next, so the pieces join into one line. Drawn by a
   pseudo-element, so no cell's width or content moves, and it stays over a
   projected row's tint. */
#boardTable .boardTableGroupRow > .boardTableGroupHeader:last-child,
#boardTable .boardTableDetailRow > .tb2.boardTableSeparator,
#boardTable tr > td:not(.tb) + td.tb{
    position: relative;
}

#boardTable .boardTableGroupRow > .boardTableGroupHeader:last-child::before,
#boardTable .boardTableDetailRow > .tb2.boardTableSeparator::before,
#boardTable tr > td:not(.tb) + td.tb::before{
    background: var(--board-rule-label);
    bottom: 0;
    content: "";
    left: 0;
    pointer-events: none;
    position: absolute;
    top: 0;
    width: 1px;
    z-index: 1;
}

/* An entry row's cells carry a border inside the column, so their piece
   reaches back over it; the percentages row above the entries has no border,
   so its piece stays at the column's edge as the header's do. The pick-5
   header cells close with a 1px border along the bottom. */
#boardTable .boardTableRow > td:not(.tb) + td.tb::before{
    bottom: calc(-1 * var(--board-cell-border));
    left: calc(-1 * var(--board-cell-border));
    top: calc(-1 * var(--board-cell-border));
}

#boardTable.pick5BoardTable .boardTableGroupRow > .boardTableGroupHeader:last-child::before{
    bottom: -1px;
}

/* The room over the first row (tbody::before, above) is a row with no cells,
   so none draws its piece of the rule; the Wins label's piece carries on down
   through it to meet the first entry's. The first entry may change as rows are
   sorted or searched away, so the piece belongs to the header, which stays. */
#boardTable.pick5BoardTable .boardTableDetailRow > .tb2.boardTableSeparator::before{
    bottom: calc(-1px - var(--pick5-first-row-gap));
}

#weekLabel{
    font-family: var(--ff-body);
    color: var(--c-text-primary);
    font-size: 9pt;
}

.disabled{
    opacity: .4;
}

.disabled:hover{
    background-color: none;
}

#comparisonSummaryRow{
    color: var(--c-text-muted);
}

/* The menu of the viewer's entries takes what its label leaves of the rank, name,
   and check columns. */
.comparisonSummaryControl{
    align-items: baseline;
    display: flex;
    gap: var(--g1);
}

#comparisonSummaryRow .selectMenuField{
    flex: 1 1 0;
    min-width: 0;
}

/* The Away and Home labels' type and right edge, in the row's flow rather than
   placed over a game's header. */
#comparisonSummaryRow .atsHeaderSideLabel{
    flex: none;
    line-height: normal;
    position: static;
}

/* A step down in type, which the em-based height and padding follow, so the menu
   does not make the row any taller than its small text. */
#comparisonSummaryRow .selectMenuButton{
    font-size: var(--fs-small3);
    height: 2em;
    padding: 0 0.6em;
}

/* The list is as wide as the entry names in it. */
#comparisonSummaryRow .selectMenuList{
    min-width: max-content;
}

#weekWinOddsValue{
    font-size: 8pt;
    font-family: var(--ff-body);
    cursor: pointer;
}

#comparisonSummaryRow{
    font-size: var(--fs-small3);
}

/* ---------------------------------------------------------------------------
   Week CSE tally

   CSE is the sum of how far each wrong pick missed its line, so the column on
   its own is a number without a reason. Hovering a cell shows the misses that
   built it, one per line.
   ------------------------------------------------------------------------ */

/* Positioned in viewport coordinates by dashboard.js and attached to <body>,
   so no ancestor's overflow can clip it and the live CSE recompute - which
   rewrites this cell's contents - cannot destroy it. */
.weekCseTooltip {
    position: fixed;
    left: 0;
    top: 0;
    z-index: 9999;

    min-width: 132px;
    padding: 7px 9px;
    box-sizing: border-box;

    background-color: var(--c1);
    color: var(--c-surface);
    border-radius: var(--r2);
    box-shadow: var(--shadow-tooltip);

    font-family: var(--ff-body);
    font-size: var(--fs-small3);
    line-height: 1.3;
    text-align: left;
    white-space: nowrap;
    pointer-events: none;

    /* Measured before it is placed, so it starts transparent rather than
       display:none - a hidden element has no dimensions to position from. */
    opacity: 0;
    transition: opacity 120ms linear;
}

.weekCseTooltip.is-visible {
    opacity: 1;
}

.weekCseTooltipHead {
    color: var(--c-text-muted);
    font-size: var(--fs-small3);
    letter-spacing: var(--ls1);
    margin-bottom: 5px;
    text-transform: uppercase;
}

/* One grid for the whole tally rather than one per row: grid tracks are only
   shared between rows of the same container, so a grid per row would size each
   row's columns to its own contents and the four columns would start at a
   different x on every line. */
.weekCseTally {
    align-items: baseline;
    column-gap: var(--g2);
    display: grid;
    grid-template-columns: auto auto minmax(0, 1fr) auto;
    row-gap: 2px;
}

/* The row is a grouping in the markup only; its four spans are the real grid
   items, so every column lines up down the whole tally. */
.weekCseTallyRow {
    display: contents;
}

.weekCseTallyTeam {
    font-weight: var(--fw3);
}

.weekCseTallyVs {
    color: var(--c-text-muted);
}

.weekCseTallyOpponent {
    text-align: left;
}

/* The total row has nothing to put in the "vs" or winning-team tracks, so its
   caption runs across both. */
.weekCseTallySpan {
    color: var(--c-text-muted);
    grid-column: 2 / 4;
}

.weekCseTallyHit {
    font-variant-numeric: tabular-nums;
    text-align: right;
}

/* No rule above the total: the spacing separates it from the misses on its own,
   and the line was the only horizontal stroke left in the tooltip. */
.weekCseTallyRow--total > span {
    margin-top: 3px;
    padding-top: 4px;
}

/* ---------------------------------------------------------------------------
   Game details

   A click on a shown pick opens its game's details - see the script at the
   end of board.php. Drawn as the CSE tally above is: white type on the
   site's ink, attached to <body> and placed in viewport coordinates. As wide
   as its longest line and no wider, with no minimum width to leave room at
   its right.
   ------------------------------------------------------------------------ */

/* A pick with details to open, on the Board and in the pick history
   modal alike. */
.teamInTD[data-game] {
    cursor: pointer;
}

.boardGameInfo {
    position: fixed;
    left: 0;
    top: 0;
    z-index: 9999;

    width: max-content;
    padding: 7px 9px;
    box-sizing: border-box;

    color: var(--c-surface);
    border-radius: var(--r2);
    box-shadow: var(--shadow-popover);

    font-family: var(--ff-body);
    font-size: var(--fs-small3);
    line-height: 1.3;
    text-align: left;
    white-space: nowrap;
}

.boardGameInfo[hidden] {
    display: none;
}

/* The pointer, as the league hero toolbar's tooltips draw theirs: a square
   rotated into a diamond and half buried under the panel, so the two share a
   colour. The placing script sets --pointer-x to the pick's middle, and
   .is-above moves it to the bottom edge when the panel opens above the pick. */
.boardGameInfo::before {
    content: "";
    height: 8px;
    left: var(--pointer-x, 50%);
    position: absolute;
    top: 0;
    transform: translate(-50%, -50%) rotate(45deg);
    width: 8px;
}

.boardGameInfo.is-above::before {
    top: 100%;
}

.boardGameInfoList {
    display: grid;
    gap: 4px;
    margin: 0;
}

.boardGameInfoList > div {
    column-gap: 10px;
    display: grid;
    grid-template-columns: 48px 1fr;
}

.boardGameInfoList dt {
    color: var(--c1-n8);
    letter-spacing: var(--ls1);
    text-transform: uppercase;
}

.boardGameInfoList dd {
    font-weight: var(--fw3);
    margin: 0;
}

/* The score row before the game starts. */
.boardGameInfoList > div[hidden] {
    display: none;
}

/* The away and home rows, as the game info panel writes a team
   (.pickGameInfoTeam in game-info-panel.css): the logo a line tall, then the
   code, then the spread in parentheses, one typed space between each. */
.boardGameInfoTeam {
    align-items: center;
    display: flex;
    min-width: 0;
}

/* A hairline glow in the panel's text colour, so a dark logo still reads
   against the dark fill. A square a line tall, which the logos are, held
   from the start: sized by the image instead, the box is nothing wide until
   the logo arrives, and the code and spread then jump right to make room. */
.boardGameInfoTeamLogo {
    display: block;
    filter: drop-shadow(0 0 1px var(--c-surface));
    flex: 0 0 auto;
    height: 1lh;
    object-fit: contain;
    transform: translateY(-1px);
    width: 1lh;
}

.boardGameInfoTeamCode {
    letter-spacing: var(--ls1);
}

.boardGameInfoTeamSpread {
    font-variant-numeric: tabular-nums;
}

.boardGameInfoTeamLogo + .boardGameInfoTeamCode::before,
.boardGameInfoTeamCode + .boardGameInfoTeamSpread::before {
    content: " ";
    white-space: pre;
}

/* Final or In progress, under the score it qualifies. */
.boardGameInfoStatus {
    color: var(--c-text-muted);
    display: block;
    font-weight: var(--fw1);
}

.boardGameInfoStatus:empty {
    display: none;
}

/* ==========================================================================
   Header labels and number columns, set as the standings table sets them
   (see the .standingsType rules in standings.css): the labels - Selections,
   Week and Season, and Wins and CSE - and the game data over the game columns.
   The odds tracker keeps its own type.
   ========================================================================== */
#boardTable {
    --board-ink-1: var(--c-text-muted);
}

#boardTable .boardTableHeaderLabel,
#boardTable .pick5PickHeader,
#boardTable .atsHeaderSideLabel {
    color: var(--board-ink-1);
    font-size: var(--fs-small2);
    font-variant-numeric: tabular-nums;
    font-weight: var(--fw3);
    text-transform: uppercase;
    letter-spacing: var(--ls1);
}

/* The group labels sit a tier above the column labels: the same capitals at a
   lighter weight, as over the standings' two sections. */
#boardTable .boardTableGroupHeader .boardTableHeaderLabel,
#boardTable .pick5PickHeader {
    font-weight: 500;
}

/* The game data over each game column - the scores, the team codes, and the
   spread - takes the same type as the labels: size, weight,
   colour, spacing, family, and tabular figures, so the spreads and scores
   stack like the columns below them. Two things are held back. Case is left
   alone, because away codes read lowercase (see .away above). And a covered or pushed code sits on its result
   fill in that result's ink: --c-win-text on the covered green,
   --c-push-text on the push fill. */
#boardTable .atsHeaderContainer .teamInATSheader,
#boardTable .atsHeaderContainer .spreadInATSheader {
    color: var(--board-ink-1);
    font-family: var(--ff-body);
    font-size: var(--fs-small2);
    font-variant-numeric: tabular-nums;
    font-weight: var(--fw3);
    letter-spacing: var(--ls1);
}

#boardTable .atsHeaderContainer .teamInATSheader.covered {
    color: var(--c-win-text);
}

#boardTable .atsHeaderContainer .teamInATSheader.xpush {
    color: var(--c-push-text);
}

#boardTable .atsHeaderContainer .teamInATSheader.simCovered,
#boardTable .atsHeaderContainer .teamInATSheader.tbd:not(.is-hoverSuppressed):hover {
    color: var(--c-win-proj);
}

/* A projected winner under the pointer looks as it would with no projection
   on its game - a click takes the projection off. A projected winner is also
   .tbd, so this has to outweigh the hover above as well as its own look.

   None of these previews shows on a team just clicked, until the pointer
   leaves it: site.js marks it .is-hoverSuppressed, so it shows what the click
   did rather than what another click would do. */
#boardTable .atsHeaderContainer .teamInATSheader.simCovered:not(.is-hoverSuppressed):hover {
    background: none;
    color: var(--board-ink-1);
    outline: none;
}

/* --- Numbers on the decimal point -----------------------------------------
   Tabular figures so every digit takes the same width, right-aligned so the
   digits stack. site.js marks a figure with no tenth, and it is given a ".0"
   that is not seen but keeps its width, so 14 ends where the 5 of 13.5 ends.
   The right padding sets the edge the figures end on so that a figure of the
   usual size, two digits and a tenth, sits in the middle of the cell under
   its centred label. The padding is measured off the column's width, not
   written as 50%: a cell's percentage padding is taken from the table's width,
   not the cell's, and --width-stat is the column's own width in pixels. */
#boardTable .boardRankCell,
#boardTable .pick5RankCell,
#boardTable td.boardTableNumbers {
    font-variant-numeric: tabular-nums;
}

#boardTable td.boardTableNumbers {
    box-sizing: border-box;
    padding-right: calc(var(--width-stat) / 2 - 1.65ch);
    text-align: right;
    white-space: nowrap;
}

#boardTable td.boardNumberWhole::after {
    content: ".0";
    visibility: hidden;
}

/* The rule above centres a figure of two digits and a tenth - the most a
   week's points reach. The other three run longer, and a figure wider than the
   room the padding leaves does not overflow to the left: it starts at the
   cell's left edge and pushes past the right, so its decimal point no longer
   lines up with the shorter figures above and below it. Each of these is set
   to centre its own longest figure instead, so every figure it will hold ends
   on the same edge:

     week CSE, season points  three digits and a tenth (4.5ch) - "404.5",
                              "188.5"
     season CSE               four digits and a tenth (about 5.5ch) -
                              "1511.5" */
#boardTable td.currentWeekCse,
#boardTable td.seasonWinCount {
    padding-right: calc(var(--width-stat) / 2 - 2.25ch);
}

#boardTable td.boardTableNumbers.tb:not(.seasonWinCount) {
    padding-right: calc(var(--width-stat) / 2 - 2.9ch);
}

/* --- The header's rules, in the standings' colours --------------------------
   The standings header has two: the faint rule under each group label (its
   text grey at .45) and the rule that closes the header (the dark ink at .22).
   The Board's rules take whichever of the two does the same job. The line
   under the pick-5 header and the one over the pick-all table's entries (see
   below) close the header; the rule under Week and Season, and the rules
   between the games, sit inside it. */
#boardTable {
    --board-rule-label: rgba(121, 132, 154, .45);
    --board-rule-header: rgba(23, 33, 54, .22);
}

#boardTable.pick5BoardTable th {
    border-bottom-color: var(--board-rule-header);
}

/* The pick-all table has no rule over it; its header is closed by one line
   directly over the entries, under the row of pick rates.

   One element spanning the row, laid on its bottom edge. It was a shadow on
   each cell, which put it 1px inside each cell's border - and the Season
   cells used to carry a 2px bottom border in their own grey, so under them the
   line sat 2px higher and the rule broke into steps. Out of flow, so the row
   does not grow by the line's height. */
#boardTable:not(.pick5BoardTable) #comparisonSummaryRow {
    position: relative;
}

#boardTable:not(.pick5BoardTable) #comparisonSummaryRow::after {
    background: var(--board-rule-header);
    bottom: var(--board-cell-edge);
    content: "";
    height: 1px;
    left: 0;
    pointer-events: none;
    position: absolute;
    right: 0;
    z-index: 2;
}

/* The percentages keep their 6px over the rule, and the first row's pills get
   one cell edge more under it. */
#boardTable:not(.pick5BoardTable) #comparisonSummaryRow > td{
    padding: 12px 0 calc(6px + var(--board-cell-edge));
    vertical-align: baseline;
}

#boardTable .boardTableGroupHeader::after {
    background: var(--board-rule-label);
}

/* A vertical rule on the left edge of every game, the first included, in the
   colour of the rules inside the header (the one under Week and Season). Full
   height, drawn by a pseudo-element, so no
   cell's width or content moves. */
#boardTable .atsHeader::before {
    background: var(--board-rule-label);
    bottom: 0;
    content: "";
    left: 0;
    pointer-events: none;
    position: absolute;
    top: 0;
    width: 1px;
    z-index: 1;
}

/* --- Home and Away, beside the first game ---------------------------------
   Which of the two team codes in each matchup is the home side, said once, to
   the left of the first game and level with its codes. The order is the first
   game's own: the league's layout can put either side on top. Out of flow, so
   the table measures exactly as it did without them, and the header cell
   beside them is left to paint underneath. The same type as the header's
   labels.

   Each label's text is level with its code's: the codes sit in the first and
   third rows of .atsHeaderContainer (25px 19px 25px), or the first and second
   when there is no spread row between them, below the container's 6px margin
   and 12px padding, and each is drawn 2px toward the spread by its margins
   (see .teamInATSheader:first-child). */
.atsHeaderSideLabels {
    bottom: 0;
    pointer-events: none;
    position: absolute;
    right: 100%;
    top: 0;
}

/* Its type is the Wins and CSE labels', from the rule they share with it (see
   #boardTable .boardTableHeaderLabel); only its placing is here. */
.atsHeaderSideLabel {
    line-height: 25px;
    padding-right: 6px;
    position: absolute;
    right: 0;
    white-space: nowrap;
}

.atsHeaderSideLabel--top {
    top: 20.5px;
}

.atsHeaderSideLabel--bottom {
    top: 60.5px;
}

.boardTable--noSpreads .atsHeaderSideLabel--bottom {
    top: 41.5px;
}

/* --- The CSE columns --------------------------------------------------------
   Set as the standings set their CSE: the grey the standings give every figure
   but the few they want compared, at regular weight in your own rows too. The
   week cell is .currentWeekCse; the season one is the .tb cell that is not the
   season wins. A column with nothing in it yet keeps the transparent ink
   .emptyColumnCell gives it in main.css. The season wins take the same grey
   but keep their own weight. */
#boardTable td.currentWeekCse:not(.emptyColumnCell),
#boardTable td.boardTableNumbers.tb:not(.seasonWinCount):not(.emptyColumnCell) {
    color: var(--board-ink-1);
    font-weight: var(--fw1);
}

#boardTable td.seasonWinCount:not(.emptyColumnCell) {
    color: var(--board-ink-1);
}

/* --- Scores above and below the team codes ----------------------------------
   A game with a result shows each team's score on the far side of its code
   from the spread: the top team's above its code, the bottom team's below it,
   in the 12px of padding .atsHeaderContainer keeps at either end. Quieter than
   the codes, and never on a result's fill - the covered and push colours are
   the codes' alone. board.php puts the score in data-score and .showScore on
   both codes; site.js takes .showScore off while results are hidden and puts
   it back.

   The score is drawn from data-score by a pseudo-element rather than written
   into the code's element: site.js reads these elements' text to match picks,
   and a pseudo-element is not part of it. It is placed against its code, past
   the code's 4px margin, and centred across the column. */
#boardTable .atsHeaderContainer .teamInATSheader.showScore {
    position: relative;
}

#boardTable .atsHeaderContainer .teamInATSheader.showScore::after {
    color: var(--board-ink-1);
    content: attr(data-score);
    font-family: var(--ff-body);
    font-size: var(--fs-small2);
    /* Upright under a projected code too: the result styling is the code's. */
    font-style: normal;
    font-variant-numeric: tabular-nums;
    font-weight: var(--fw1);
    left: -4px;
    letter-spacing: 0;
    line-height: 12px;
    opacity: .8;
    position: absolute;
    right: -4px;
    text-align: center;
    white-space: nowrap;
}

/* The 2px between the score and its code is the score's padding rather than
   space outside it, so the code and its score are one unbroken target for a
   click and the pointer - an override, and its hover preview - with no dead
   strip between them. */
#boardTable .atsHeaderContainer .teamInATSheader.showScore:first-child::after {
    bottom: 100%;
    padding-bottom: 4px;
}

#boardTable .atsHeaderContainer .teamInATSheader.showScore:last-child::after {
    padding-top: 4px;
    top: 100%;
}

/* --- The favourite's mark beside each spread -------------------------------
   A play triangle, which points right, turned counterclockwise: 90 degrees for
   an away favourite, so it points up, and 270 for a home favourite, so it
   points down - towards the favourite while the away team sits on top, as it
   does on the Board.

   It is Font Awesome's fa-play drawn as an SVG with its corners made sharp: the
   glyph's three straight edges, in its own 384 x 512 grid, run on to where
   they meet instead of turning in rounded corners - so the points reach a
   little past the glyph's rounded tips, and every edge is where it was. The
   box is the glyph's: .75em by 1em, plus the .24px the spread's letter spacing
   put after the glyph, which is part of the box the turn is centred on. The
   points overflow the box, so it does not clip them. */
.spreadFavoriteMark{
    box-sizing: content-box;
    display: block;
    font-size: 6px;
    height: 1em;
    margin-right: 1px;
    overflow: visible;
    padding-right: .24px;
    width: .75em;
}

/* Each is nudged 2px the way it points - up for an away favourite, down for a
   home one - a relative shift, so the number beside it does not move. */
.spreadFavoriteMark--away {
    position: relative;
    top: -2px;
    transform: rotate(-90deg);
}

.spreadFavoriteMark--home {
    position: relative;
    top: 1px;
    transform: rotate(-270deg);
}
