{-# LANGUAGE OverloadedStrings #-}
-- | Infrastructure for parsing & desugaring grid-layout related CSS properties.
module Graphics.Layout.Grid.CSS(CSSGrid(..), Axis(..), CSSCell(..), Placement(..),
                                finalizeGrid, Areas, parseASCIIGrid) where

import Stylist (PropertyParser(..), parseOperands)
import Data.CSS.Syntax.Tokens (Token(..), NumericValue(..))

import Data.Text (Text)
import qualified Data.Text as Txt
import Data.Char (isAlphaNum)
import Data.Maybe (fromMaybe, isNothing)
import Data.List (nub)
import qualified Data.HashMap.Lazy as HM

import Graphics.Layout.CSS.Length
import Graphics.Layout.Box
import Graphics.Layout.Grid
import Graphics.Layout

type Areas = HM.HashMap Text ((Int, Int), (Int, Maybe Int))

-- | Converts a grid to lookup table start & indices for row & columns.
-- Exported for the sake of testing
parseASCIIGrid :: [[Text]] -> Int -> Areas -> Maybe Areas
parseASCIIGrid :: [[Text]] -> Int -> Areas -> Maybe Areas
parseASCIIGrid ([Text]
row:[[Text]]
rows) Int
i Areas
prev
    | [Text]
names forall a. Eq a => a -> a -> Bool
== forall a. Eq a => [a] -> [a]
nub [Text]
names, forall (t :: * -> *). Foldable t => t Bool -> Bool
and [(Int, Int)
span forall a. Eq a => a -> a -> Bool
== forall a b. (a, b) -> a
fst ((Int, Int), (Int, Maybe Int))
rec Bool -> Bool -> Bool
&& forall a. Maybe a -> Bool
isNothing (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a b. (a, b) -> b
snd ((Int, Int), (Int, Maybe Int))
rec)
            | (Text
name, (Int, Int)
span) <- [(Text, (Int, Int))]
row', Just ((Int, Int), (Int, Maybe Int))
rec <- [Text
name forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
`HM.lookup` Areas
prev]] =
        [[Text]] -> Int -> Areas -> Maybe Areas
parseASCIIGrid [[Text]]
rows (forall a. Enum a => a -> a
succ Int
i) forall a b. (a -> b) -> a -> b
$ forall k v1 v2. (k -> v1 -> v2) -> HashMap k v1 -> HashMap k v2
HM.mapWithKey forall {a} {a}. Text -> (a, (a, Maybe Int)) -> (a, (a, Maybe Int))
closeAreas forall a b. (a -> b) -> a -> b
$ forall k v.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k v -> HashMap k v
HM.union Areas
prev forall a b. (a -> b) -> a -> b
$
            forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HM.fromList [(Text
name, ((Int, Int)
span, (Int
i, forall a. Maybe a
Nothing))) | (Text
name, (Int, Int)
span) <- [(Text, (Int, Int))]
row']
    | Bool
otherwise = forall a. Maybe a
Nothing
  where
    names :: [Text]
names = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(Text, (Int, Int))]
row'
    row' :: [(Text, (Int, Int))]
row' = forall {a}. Eq a => [(Int, a)] -> [(a, (Int, Int))]
parseAsciiRow forall a b. (a -> b) -> a -> b
$ forall {b}. [b] -> [(Int, b)]
enumerate [Text]
row
    parseAsciiRow :: [(Int, a)] -> [(a, (Int, Int))]
parseAsciiRow ((Int
j, a
cell):[(Int, a)]
cells) =
        let ([(Int, a)]
self, [(Int, a)]
cells') = forall a. (a -> Bool) -> [a] -> ([a], [a])
span (\(Int, a)
z -> forall a b. (a, b) -> b
snd (Int, a)
z forall a. Eq a => a -> a -> Bool
== a
cell) [(Int, a)]
cells
        in (a
cell, (Int
j, forall a. Enum a => a -> a
succ Int
j forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. Foldable t => t a -> Int
length [(Int, a)]
self))forall a. a -> [a] -> [a]
:[(Int, a)] -> [(a, (Int, Int))]
parseAsciiRow [(Int, a)]
cells'
    parseAsciiRow [] = []
    enumerate :: [b] -> [(Int, b)]
enumerate = forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..]
    closeAreas :: Text -> (a, (a, Maybe Int)) -> (a, (a, Maybe Int))
closeAreas Text
name (a
a, (a
b, Maybe Int
Nothing)) | Text
name forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Text]
names = (a
a, (a
b, forall a. a -> Maybe a
Just Int
i))
    closeAreas Text
_ (a, (a, Maybe Int))
ret = (a, (a, Maybe Int))
ret
parseASCIIGrid [] Int
_ Areas
ret = forall a. a -> Maybe a
Just Areas
ret

-- | Parsed CSS Grid properties
data CSSGrid = CSSGrid {
    -- | Parsed CSS grid-auto-columns
    CSSGrid -> Unitted
autoColumns :: Unitted,
    -- | Parsed grid-auto-flow
    CSSGrid -> Axis
autoFlow :: Axis,
    -- | Whether grid-auto-flow: dense was specified.
    CSSGrid -> Bool
autoFlowDense :: Bool,
    -- | Parsed CSS grid-auto-rows
    CSSGrid -> Unitted
autoRows :: Unitted,
    -- | Parsed CSS grid-template-areas
    CSSGrid -> Areas
templateAreas :: Areas,
    -- | Parsed CSS grid-template-columns
    CSSGrid -> [([Text], Unitted)]
templateColumns :: [([Text], Unitted)],
    -- | Parsed CSS grid-template-rows
    CSSGrid -> [([Text], Unitted)]
templateRows :: [([Text], Unitted)],
    -- | Parsed CSS row-gap & column-gap
    CSSGrid -> Size Unitted Unitted
cssGap :: Size Unitted Unitted,
    -- | Parsed CSS justify-items & align-items
    CSSGrid -> Size Alignment Alignment
alignItems :: Size Alignment Alignment
}
-- | A grid axis.
data Axis = Row | Col deriving Axis -> Axis -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Axis -> Axis -> Bool
$c/= :: Axis -> Axis -> Bool
== :: Axis -> Axis -> Bool
$c== :: Axis -> Axis -> Bool
Eq
-- | Parsed CSS grid item properties.
data CSSCell = CSSCell {
    -- | Parsed CSS grid-column-start
    CSSCell -> Placement
columnStart :: Placement,
    -- | Parsed CSS grid-column-end
    CSSCell -> Placement
columnEnd :: Placement,
    -- | Parsed CSS grid-row-start
    CSSCell -> Placement
rowStart :: Placement,
    -- | Parsed CSS grid-row-end
    CSSCell -> Placement
rowEnd :: Placement,
    -- | Parsed CSS align-self & justify-self
    CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
}
-- | Identifies a cell in the CSS grid.
data Placement = Autoplace | Named Text | Numbered Int (Maybe Text) |
        Span Int (Maybe Text)

instance PropertyParser CSSGrid where
    temp :: CSSGrid
temp = CSSGrid {
        autoColumns :: Unitted
autoColumns = Unitted
auto,
        autoFlow :: Axis
autoFlow = Axis
Row,
        autoFlowDense :: Bool
autoFlowDense = Bool
False,
        autoRows :: Unitted
autoRows = Unitted
auto,
        templateAreas :: Areas
templateAreas = forall k v. HashMap k v
HM.empty,
        templateColumns :: [([Text], Unitted)]
templateColumns = [],
        templateRows :: [([Text], Unitted)]
templateRows = [],
        cssGap :: Size Unitted Unitted
cssGap = forall m n. n -> m -> Size m n
Size (Double
0,Text
"px") (Double
0,Text
"px"),
        alignItems :: Size Alignment Alignment
alignItems = forall m n. n -> m -> Size m n
Size Alignment
Start Alignment
Start -- FIXME: Should be stretch, unsupported.
    }
    inherit :: CSSGrid -> CSSGrid
inherit CSSGrid
_ = forall a. PropertyParser a => a
temp
    priority :: CSSGrid -> [Text]
priority CSSGrid
_ = []

    longhand :: CSSGrid -> CSSGrid -> Text -> [Token] -> Maybe CSSGrid
longhand CSSGrid
_ CSSGrid
s Text
"grid-auto-columns" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseFR [Token]
toks = forall a. a -> Maybe a
Just CSSGrid
s {autoColumns :: Unitted
autoColumns=Unitted
x}
    longhand CSSGrid
_ CSSGrid
s Text
"grid-auto-rows" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseFR [Token]
toks = forall a. a -> Maybe a
Just CSSGrid
s { autoRows :: Unitted
autoRows = Unitted
x }

    longhand CSSGrid
_ CSSGrid
self Text
"grid-auto-flow" [Ident Text
"row"] = forall a. a -> Maybe a
Just CSSGrid
self {
        autoFlow :: Axis
autoFlow = Axis
Row, autoFlowDense :: Bool
autoFlowDense = Bool
False
      }
    longhand CSSGrid
_ CSSGrid
self Text
"grid-auto-flow" [Ident Text
"column"] = forall a. a -> Maybe a
Just CSSGrid
self {
        autoFlow :: Axis
autoFlow = Axis
Col, autoFlowDense :: Bool
autoFlowDense = Bool
False
      }
    longhand CSSGrid
_ CSSGrid
self Text
"grid-auto-flow" [Ident Text
"row", Ident Text
"dense"] = forall a. a -> Maybe a
Just CSSGrid
self {
        autoFlow :: Axis
autoFlow = Axis
Row, autoFlowDense :: Bool
autoFlowDense = Bool
True
      }
    longhand CSSGrid
_ CSSGrid
self Text
"grid-auto-flow" [Ident Text
"column", Ident Text
"dense"] = forall a. a -> Maybe a
Just CSSGrid
self {
        autoFlow :: Axis
autoFlow = Axis
Col, autoFlowDense :: Bool
autoFlowDense = Bool
True
      }

    -- FIXME Parse & validate the ASCII-art grid into rectangles.
    longhand CSSGrid
_ CSSGrid
self Text
"grid-template-areas" [Ident Text
"none"] =
        forall a. a -> Maybe a
Just CSSGrid
self { templateAreas :: Areas
templateAreas = forall k v. HashMap k v
HM.empty }
    longhand CSSGrid
_ CSSGrid
self Text
"grid-template-areas" [Ident Text
"initial"] =
        forall a. a -> Maybe a
Just CSSGrid
self { templateAreas :: Areas
templateAreas = forall k v. HashMap k v
HM.empty }
    longhand CSSGrid
_ CSSGrid
self Text
"grid-template-areas" [Token]
toks
        | forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Token -> Bool
isString [Token]
toks, let grid :: [[Text]]
grid = [Text -> [Text]
Txt.words Text
x | String Text
x <- [Token]
toks],
            [[Text]] -> Bool
validate [[Text]]
grid, Just Areas
areas <- [[Text]] -> Int -> Areas -> Maybe Areas
parseASCIIGrid [[Text]]
grid Int
0 forall k v. HashMap k v
HM.empty =
                forall a. a -> Maybe a
Just CSSGrid
self { templateAreas :: Areas
templateAreas = Areas
areas }
      where
        isString :: Token -> Bool
isString (String Text
_) = Bool
True
        isString Token
_ = Bool
False
        validate :: [[Text]] -> Bool
validate grid :: [[Text]]
grid@([Text]
row:[[Text]]
rows) =
            forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Text -> Bool
isValidName (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Text]]
grid) Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\[Text]
x -> forall (t :: * -> *) a. Foldable t => t a -> Int
length [Text]
row forall a. Eq a => a -> a -> Bool
== forall (t :: * -> *) a. Foldable t => t a -> Int
length [Text]
x) [[Text]]
rows
        validate [] = Bool
False
        isValidName :: Text -> Bool
isValidName Text
name = (Char -> Bool) -> Text -> Bool
Txt.all (\Char
c -> Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'-') Text
name

    longhand CSSGrid
_ CSSGrid
self Text
"grid-template-columns" [Token]
toks | Just [([Text], Unitted)]
x <- [Token] -> Maybe [([Text], Unitted)]
parseTemplate [Token]
toks =
        forall a. a -> Maybe a
Just CSSGrid
self { templateColumns :: [([Text], Unitted)]
templateColumns = [([Text], Unitted)]
x }
    longhand CSSGrid
_ CSSGrid
self Text
"grid-template-rows" [Token]
toks | Just [([Text], Unitted)]
x <- [Token] -> Maybe [([Text], Unitted)]
parseTemplate [Token]
toks =
        forall a. a -> Maybe a
Just CSSGrid
self { templateRows :: [([Text], Unitted)]
templateRows = [([Text], Unitted)]
x}

    longhand CSSGrid
_ CSSGrid
self Text
"row-gap" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSGrid
self { cssGap :: Size Unitted Unitted
cssGap = (CSSGrid -> Size Unitted Unitted
cssGap CSSGrid
self) { inline :: Unitted
inline = Unitted
x } }
    longhand CSSGrid
_ CSSGrid
self Text
"column-gap" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSGrid
self { cssGap :: Size Unitted Unitted
cssGap = (CSSGrid -> Size Unitted Unitted
cssGap CSSGrid
self) { block :: Unitted
block = Unitted
x } }

    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"start"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"flex-start"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"self-start"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"left"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"center"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Mid } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"end"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
End } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"flex-end"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
End } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"self-end"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
End } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"right"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
End } }
    longhand CSSGrid
parent CSSGrid
self Text
"justify-items" (Ident Text
"unsafe":[Token]
toks) =
        forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSGrid
parent CSSGrid
self Text
"justify-items" [Token]
toks
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"normal"] = -- FIXME Should be stretch, unsupported.
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"justify-items" [Ident Text
"initial"] = -- FIXME Should be stretch, unsupported.
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { inline :: Alignment
inline = Alignment
Start } }

    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"start"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"flex-start"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"self-start"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"center"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Mid } }
    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"end"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
End } }
    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"flex-end"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
End } }
    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"self-end"] =
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
End } }
    longhand CSSGrid
parent CSSGrid
self Text
"align-items" (Ident Text
"unsafe":[Token]
toks) =
        forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSGrid
parent CSSGrid
self Text
"align-items" [Token]
toks
    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"normal"] = -- FIXME Should be stretch, unsupported.
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }
    longhand CSSGrid
_ CSSGrid
self Text
"align-items" [Ident Text
"initial"] = -- FIXME Should be stretch, unsupported.
        forall a. a -> Maybe a
Just CSSGrid
self { alignItems :: Size Alignment Alignment
alignItems = (CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) { block :: Alignment
block = Alignment
Start } }

    longhand CSSGrid
_ CSSGrid
_ Text
_ [Token]
_ = forall a. Maybe a
Nothing

instance PropertyParser CSSCell where
    temp :: CSSCell
temp = CSSCell {
        columnStart :: Placement
columnStart = Placement
Autoplace,
        columnEnd :: Placement
columnEnd = Placement
Autoplace,
        rowStart :: Placement
rowStart = Placement
Autoplace,
        rowEnd :: Placement
rowEnd = Placement
Autoplace,
        alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = forall m n. n -> m -> Size m n
Size forall a. Maybe a
Nothing forall a. Maybe a
Nothing
    }
    inherit :: CSSCell -> CSSCell
inherit CSSCell
_ = forall a. PropertyParser a => a
temp
    priority :: CSSCell -> [Text]
priority CSSCell
_ = []

    longhand :: CSSCell -> CSSCell -> Text -> [Token] -> Maybe CSSCell
longhand CSSCell
_ CSSCell
self Text
"grid-column-start" [Token]
toks | Just Placement
x <- [Token] -> Maybe Placement
placement [Token]
toks =
        forall a. a -> Maybe a
Just CSSCell
self { columnStart :: Placement
columnStart = Placement
x}
    longhand CSSCell
_ CSSCell
s Text
"grid-column-end" [Token]
toks | Just Placement
x <- [Token] -> Maybe Placement
placement [Token]
toks = forall a. a -> Maybe a
Just CSSCell
s {columnEnd :: Placement
columnEnd=Placement
x}
    longhand CSSCell
_ CSSCell
s Text
"grid-row-start" [Token]
toks | Just Placement
x <- [Token] -> Maybe Placement
placement [Token]
toks = forall a. a -> Maybe a
Just CSSCell
s {rowStart :: Placement
rowStart = Placement
x}
    longhand CSSCell
_ CSSCell
s Text
"grid-row-end" [Token]
toks | Just Placement
x <- [Token] -> Maybe Placement
placement [Token]
toks = forall a. a -> Maybe a
Just CSSCell
s { rowEnd :: Placement
rowEnd = Placement
x }

    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"start"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"self-start"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"flex-start"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"center"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. a -> Maybe a
Just Alignment
Mid } }
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"end"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. a -> Maybe a
Just Alignment
End } }
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"self-end"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. a -> Maybe a
Just Alignment
End } }
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"flex-end"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. a -> Maybe a
Just Alignment
End } }
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"normal"] = -- FIXME should be stretch, unsupported
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
parent CSSCell
self Text
"align-self" (Ident Text
"unsafe":[Token]
toks) =
        forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
parent CSSCell
self Text
"align-self" [Token]
toks
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"auto"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. Maybe a
Nothing } }
    longhand CSSCell
_ CSSCell
self Text
"align-self" [Ident Text
"initial"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { block :: Maybe Alignment
block = forall a. Maybe a
Nothing } }

    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"start"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"self-start"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"flex-start"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"left"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"center"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
Mid } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"end"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
End } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"self-end"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
End } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"flex-end"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
End } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"right"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
End } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"normal"] = -- FIXME should be stretch, unsupported
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. a -> Maybe a
Just Alignment
Start } }
    longhand CSSCell
parent CSSCell
self Text
"justify-self" (Ident Text
"unsafe":[Token]
toks) =
        forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
parent CSSCell
self Text
"justify-self" [Token]
toks
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"auto"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. Maybe a
Nothing } }
    longhand CSSCell
_ CSSCell
self Text
"justify-self" [Ident Text
"initial"] =
        forall a. a -> Maybe a
Just CSSCell
self { alignSelf :: Size (Maybe Alignment) (Maybe Alignment)
alignSelf = (CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
self) { inline :: Maybe Alignment
inline = forall a. Maybe a
Nothing } }

    longhand CSSCell
_ CSSCell
_ Text
_ [Token]
_ = forall a. Maybe a
Nothing

    shorthand :: CSSCell -> Text -> [Token] -> Props
shorthand CSSCell
_ Text
"grid-column" [Token]
toks = case forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim Char
'/') [Token]
toks of
        ([Token]
a, Delim Char
'/':[Token]
b) | Just Placement
_ <- [Token] -> Maybe Placement
placement [Token]
a, Just Placement
_ <- [Token] -> Maybe Placement
placement [Token]
b ->
            [(Text
"grid-column-start", [Token]
a), (Text
"grid-column-end", [Token]
b)]
        ([Token], [Token])
_ | Just Placement
_ <- [Token] -> Maybe Placement
placement [Token]
toks ->
            [(Text
"grid-column-start", [Token]
toks), (Text
"grid-column-end", [Token]
toks)]
        ([Token], [Token])
_ -> []
    shorthand CSSCell
self Text
"grid-gap" [Token]
toks = case [Token] -> [[Token]]
parseOperands [Token]
toks of
        [[Token]
a] | Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-row-gap" [Token]
a ->
            [(Text
"grid-row-gap", [Token]
a), (Text
"grid-column-gap", [Token]
a)]
        [[Token]
a, [Token]
b] | Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-row-gap" [Token]
a,
            Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-column-gap" [Token]
b ->
                [(Text
"grid-row-gap", [Token]
a), (Text
"grid-column-gap", [Token]
b)]
        [[Token]]
_ -> []
    shorthand CSSCell
_ Text
"grid-row" [Token]
toks = case forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim Char
'/') [Token]
toks of
        ([Token]
a, Delim Char
'/':[Token]
b) | Just Placement
_ <- [Token] -> Maybe Placement
placement [Token]
a, Just Placement
_ <- [Token] -> Maybe Placement
placement [Token]
b ->
            [(Text
"grid-row-start", [Token]
a), (Text
"grid-row-end", [Token]
b)]
        ([Token], [Token])
_ | Just Placement
_ <- [Token] -> Maybe Placement
placement [Token]
toks ->
            [(Text
"grid-row-start", [Token]
toks), (Text
"grid-row-end", [Token]
toks)]
        ([Token], [Token])
_ -> []
    shorthand CSSCell
_ Text
"grid-template" toks :: [Token]
toks@[Ident Text
"none"] =
        [(Text
"grid-template-columns", [Token]
toks), (Text
"grid-template-rows", [Token]
toks),
         (Text
"grid-template-areas", [Token]
toks)]
    shorthand CSSCell
self Text
"grid-template" [Token]
toks
        | ([Token]
rows, Delim Char
'/':[Token]
cols) <- forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim Char
'/') [Token]
toks,
            Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-rows" [Token]
rows,
            Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-columns" [Token]
cols =
                [(Text
"grid-template-rows", [Token]
rows), (Text
"grid-template-columns", [Token]
cols),
                 (Text
"grid-template-areas", [Text -> Token
Ident Text
"none"])]
        | ([Token]
rowsTemplate, Delim Char
'/':[Token]
cols) <- forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim Char
'/') [Token]
toks,
            Just ([Token]
areas, [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
rowsTemplate,
            Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-cols" [Token]
cols,
            Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-areas" [Token]
areas =
                [(Text
"grid-template-rows", forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Token]]
rows),
                 (Text
"grid-template-columns", [Token]
cols), (Text
"grid-template-areas", [Token]
areas)]
      where
        splitTemplate :: [Token] -> Maybe ([Token], [[Token]])
splitTemplate (Token
LeftSquareBracket:[Token]
t)
            | ([Token]
names, Token
RightSquareBracket:[Token]
t') <- forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Token
RightSquareBracket) [Token]
t,
              forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Token -> Bool
isIdent [Token]
names, Just ([Token]
areas, [Token]
row:[[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
t' =
                forall a. a -> Maybe a
Just ([Token]
areas,
                    (Token
LeftSquareBracketforall a. a -> [a] -> [a]
:[Token]
names forall a. [a] -> [a] -> [a]
++ Token
RightSquareBracketforall a. a -> [a] -> [a]
:[Token]
row)forall a. a -> [a] -> [a]
:[[Token]]
rows)
        splitTemplate (x :: Token
x@(String Text
_):[Token]
toks)
            | Just ([Token]
areas, [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate' [Token]
toks = forall a. a -> Maybe a
Just (Token
xforall a. a -> [a] -> [a]
:[Token]
areas, [[Token]]
rows)
        splitTemplate [Token]
_ = forall a. Maybe a
Nothing
        splitTemplate' :: [Token] -> Maybe ([Token], [[Token]])
splitTemplate' (Token
x:Token
LeftSquareBracket:[Token]
t)
            | ([Token]
names, Token
RightSquareBracket:[Token]
t') <- forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Token
RightSquareBracket) [Token]
t,
              forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Token -> Bool
isIdent [Token]
names, Just Unitted
_ <- [Token] -> Maybe Unitted
parseFR' [Token
x],
              Just ([Token]
areas, [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
t' =
                forall a. a -> Maybe a
Just ([Token]
areas,
                    (Token
xforall a. a -> [a] -> [a]
:Token
LeftSquareBracketforall a. a -> [a] -> [a]
:[Token]
names forall a. [a] -> [a] -> [a]
++ [Token
RightSquareBracket])forall a. a -> [a] -> [a]
:[[Token]]
rows)
        splitTemplate' (Token
x:[Token]
toks)
            | Just Unitted
_ <- [Token] -> Maybe Unitted
parseFR' [Token
x], Just ([Token]
areas, [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
toks =
                forall a. a -> Maybe a
Just ([Token]
areas, [Token
x]forall a. a -> [a] -> [a]
:[[Token]]
rows)
        splitTemplate' (Token
LeftSquareBracket:[Token]
t)
            | ([Token]
names, Token
RightSquareBracket:[Token]
t') <- forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Token
RightSquareBracket) [Token]
t,
              forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Token -> Bool
isIdent [Token]
names, Just ([Token]
areas, [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
t' =
                forall a. a -> Maybe a
Just ([Token]
areas,
                    (Token
LeftSquareBracketforall a. a -> [a] -> [a]
:[Token]
names forall a. [a] -> [a] -> [a]
++ [Token
RightSquareBracket])forall a. a -> [a] -> [a]
:[[Token]]
rows)
        splitTemplate' [Token]
toks
            | Just ([Token]
areas, [[Token]]
rows) <- [Token] -> Maybe ([Token], [[Token]])
splitTemplate [Token]
toks = forall a. a -> Maybe a
Just ([Token]
areas, []forall a. a -> [a] -> [a]
:[[Token]]
rows)
            | Bool
otherwise = forall a. Maybe a
Nothing
        isIdent :: Token -> Bool
isIdent (Ident Text
_) = Bool
True
        isIdent Token
_ = Bool
False
    shorthand CSSCell
self Text
"grid" [Token]
toks
        | ret :: Props
ret@((Text, [Token])
_:Props
_) <- forall a. PropertyParser a => a -> Text -> [Token] -> Props
shorthand CSSCell
self Text
"grid-template" [Token]
toks =
            (Text
"grid-auto-flow", [Text -> Token
Ident Text
"row"])forall a. a -> [a] -> [a]
:Props
ret
    shorthand CSSCell
self Text
"grid" [Token]
toks = case forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Char -> Token
Delim Char
'/') [Token]
toks of
        ([Token]
rows, Delim Char
'/':Ident Text
"auto-flow":Ident Text
"dense":[Token]
cols) |
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-rows" [Token]
rows,
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-auto-columns" [Token]
cols ->
            [(Text
"grid-template-rows", [Token]
rows),
             (Text
"grid-template-columns", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-columns", [Token]
cols), (Text
"grid-auto-rows", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-flow", [Text -> Token
Ident Text
"column", Text -> Token
Ident Text
"dense"])]
        ([Token]
rows, Delim Char
'/':Ident Text
"dense":Ident Text
"auto-flow":[Token]
cols) |
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-rows" [Token]
rows,
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-auto-columns" [Token]
cols ->
            [(Text
"grid-template-rows", [Token]
rows),
             (Text
"grid-template-columns", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-columns", [Token]
cols), (Text
"grid-auto-rows", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-flow", [Text -> Token
Ident Text
"column", Text -> Token
Ident Text
"dense"])]
        ([Token]
rows, Delim Char
'/':Ident Text
"auto-flow":[Token]
cols) |
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-rows" [Token]
rows,
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-auto-columns" [Token]
cols ->
            [(Text
"grid-template-rows", [Token]
rows),
             (Text
"grid-template-columns", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-columns", [Token]
cols), (Text
"grid-auto-rows", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-flow", [Text -> Token
Ident Text
"column"])]
        (Ident Text
"auto-flow":Ident Text
"dense":[Token]
rows, Delim Char
'/':[Token]
cols) |
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-auto-rows" [Token]
rows,
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-columns" [Token]
cols ->
            [(Text
"grid-auto-rows", [Token]
rows), (Text
"grid-auto-columns", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-template-columns", [Token]
cols),
             (Text
"grid-template-rows", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-flow", [Text -> Token
Ident Text
"row", Text -> Token
Ident Text
"dense"])]
        (Ident Text
"dense":Ident Text
"auto-flow":[Token]
rows, Delim Char
'/':[Token]
cols) |
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-auto-rows" [Token]
rows,
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-columns" [Token]
cols ->
            [(Text
"grid-auto-rows", [Token]
rows), (Text
"grid-auto-columns", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-template-columns", [Token]
cols),
             (Text
"grid-template-rows", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-flow", [Text -> Token
Ident Text
"row", Text -> Token
Ident Text
"dense"])]
        (Ident Text
"auto-flow":[Token]
rows, Delim Char
'/':[Token]
cols) |
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-auto-rows" [Token]
rows,
          Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
"grid-template-columns" [Token]
cols ->
            [(Text
"grid-auto-rows", [Token]
rows), (Text
"grid-auto-columns", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-template-columns", [Token]
cols),
             (Text
"grid-template-rows", [Text -> Token
Ident Text
"none"]),
             (Text
"grid-auto-flow", [Text -> Token
Ident Text
"row"])]
        ([Token], [Token])
_ -> []
    shorthand CSSCell
self Text
k [Token]
v | Just CSSCell
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSCell
self CSSCell
self Text
k [Token]
v = [(Text
k, [Token]
v)]
        | Bool
otherwise = []

-- | Parse a length or FR unit.
parseFR :: [Token] -> Maybe Unitted
parseFR [Dimension Text
_ NumericValue
x Text
"fr"] = forall a. a -> Maybe a
Just (forall x. (Fractional x, RealFloat x) => NumericValue -> x
n2f NumericValue
x,Text
"fr")
parseFR [Token]
toks = [Token] -> Maybe Unitted
parseLength [Token]
toks
-- | Parse a length or FR unit, including extended keywords.
parseFR' :: [Token] -> Maybe Unitted
parseFR' [Dimension Text
_ NumericValue
x Text
"fr"] = forall a. a -> Maybe a
Just (forall x. (Fractional x, RealFloat x) => NumericValue -> x
n2f NumericValue
x,Text
"fr")
parseFR' [Token]
toks = [Token] -> Maybe Unitted
parseLength' [Token]
toks

-- | Parse an identifier for a grid cell.
placement :: [Token] -> Maybe Placement
placement [Ident Text
"auto"] = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Placement
Autoplace
placement [Ident Text
x] = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Text -> Placement
Named Text
x
placement [Number Text
_ (NVInteger Integer
x)] = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Numbered (forall a. Enum a => a -> Int
fromEnum Integer
x) forall a. Maybe a
Nothing
placement [Number Text
_ (NVInteger Integer
x), Ident Text
y] = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Numbered (forall a. Enum a => a -> Int
fromEnum Integer
x) (forall a. a -> Maybe a
Just Text
y)
placement [Ident Text
"span", Number Text
_ (NVInteger Integer
x)]
    | Integer
x forall a. Ord a => a -> a -> Bool
> Integer
0 = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span (forall a. Enum a => a -> Int
fromEnum Integer
x) forall a. Maybe a
Nothing
placement [Ident Text
"span", Ident Text
x] = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span Int
1 forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Text
x
placement [Ident Text
"span", Number Text
_ (NVInteger Integer
x), Ident Text
y]
    | Integer
x forall a. Ord a => a -> a -> Bool
> Integer
0 = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span (forall a. Enum a => a -> Int
fromEnum Integer
x) (forall a. a -> Maybe a
Just Text
y)
placement [Ident Text
"span", Ident Text
y, Number Text
_ (NVInteger Integer
x)]
    | Integer
x forall a. Ord a => a -> a -> Bool
> Integer
0 = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span (forall a. Enum a => a -> Int
fromEnum Integer
x) (forall a. a -> Maybe a
Just Text
y)
placement [Token]
_ = forall a. Maybe a
Nothing

-- | Parse grid-template-*
parseTemplate :: [Token] -> Maybe [([Text], Unitted)]
parseTemplate [Ident Text
"none"] = forall a. a -> Maybe a
Just []
parseTemplate [Ident Text
"initial"] = forall a. a -> Maybe a
Just []
parseTemplate [Token]
toks | (tracks :: [([Text], Unitted)]
tracks@(([Text], Unitted)
_:[([Text], Unitted)]
_), []) <- [Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks = forall a. a -> Maybe a
Just [([Text], Unitted)]
tracks
parseTemplate [Token]
_ = forall a. Maybe a
Nothing
-- | Parse an individual track specified by grid-template-*
parseTrack :: [Token] -> ([([Text], Unitted)], [Token])
parseTrack (Token
LeftSquareBracket:[Token]
toks)
    | Just ([Text]
names', [Token]
toks') <- [Token] -> Maybe ([Text], [Token])
parseNames [Token]
toks,
        (([Text]
names,Unitted
size):[([Text], Unitted)]
cells,[Token]
toks) <- [Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks' = (([Text]
names' forall a. [a] -> [a] -> [a]
++ [Text]
names,Unitted
size)forall a. a -> [a] -> [a]
:[([Text], Unitted)]
cells,[Token]
toks)
    | Just ([Text]
names', [Token]
toks') <- [Token] -> Maybe ([Text], [Token])
parseNames [Token]
toks = ([([Text]
names',(Double
0,Text
"end"))],[Token]
toks')
parseTrack (Token
tok:[Token]
toks) | Just Unitted
x <- [Token] -> Maybe Unitted
parseFR' [Token
tok] =
    (([], Unitted
x)forall a. a -> [a] -> [a]
:forall a b. (a, b) -> a
fst ([Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks), forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ [Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks)
parseTrack (Function Text
"repeat":Number Text
_ (NVInteger Integer
x):Token
Comma:[Token]
toks)
    | Integer
x forall a. Ord a => a -> a -> Bool
> Integer
0, (tracks :: [([Text], Unitted)]
tracks@(([Text], Unitted)
_:[([Text], Unitted)]
_), Token
RightParen:[Token]
toks') <- [Token] -> ([([Text], Unitted)], [Token])
parseTrack [Token]
toks =
        (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall a b. (a -> b) -> a -> b
$ forall a. Int -> a -> [a]
replicate (forall a. Enum a => a -> Int
fromEnum Integer
x) [([Text], Unitted)]
tracks, [Token]
toks')
parseTrack [Token]
toks = ([], [Token]
toks)
-- | (UNUSED) Parse a subgrid specified by grid-template-*
parseSubgrid :: [Token] -> ([[Text]], [Token])
parseSubgrid (Token
LeftSquareBracket:[Token]
toks)
    | Just ([Text]
names', [Token]
toks') <- [Token] -> Maybe ([Text], [Token])
parseNames [Token]
toks, ([[Text]]
names,[Token]
toks'') <- [Token] -> ([[Text]], [Token])
parseSubgrid [Token]
toks' =
        ([Text]
names' forall a. a -> [a] -> [a]
: [[Text]]
names, [Token]
toks')
parseSubgrid (Function Text
"repeat":Number Text
_ (NVInteger Integer
x):Token
Comma:[Token]
toks)
    | Integer
x forall a. Ord a => a -> a -> Bool
> Integer
0, (names :: [[Text]]
names@([Text]
_:[[Text]]
_), Token
RightParen:[Token]
toks') <- [Token] -> ([[Text]], [Token])
parseSubgrid [Token]
toks =
        (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall a b. (a -> b) -> a -> b
$ forall a. Int -> a -> [a]
replicate (forall a. Enum a => a -> Int
fromEnum Integer
x) [[Text]]
names, [Token]
toks')
parseSubgrid [Token]
toks = ([], [Token]
toks)
-- | Parse a track's names.
parseNames :: [Token] -> Maybe ([Text], [Token])
parseNames (Ident Text
x:[Token]
toks)
    | Just ([Text]
names,[Token]
toks') <- [Token] -> Maybe ([Text], [Token])
parseNames [Token]
toks = forall a. a -> Maybe a
Just (Text
xforall a. a -> [a] -> [a]
:[Text]
names,[Token]
toks')
parseNames (Token
RightSquareBracket:[Token]
toks) = forall a. a -> Maybe a
Just ([], [Token]
toks)
parseNames [Token]
_ = forall a. Maybe a
Nothing

-- | Desugar grid properties to a grid layout.
finalizeGrid :: PropertyParser x => CSSGrid -> Font' ->
    [CSSCell] -> [LayoutItem Length Length x] -> LayoutItem Length Length x
finalizeGrid :: forall x.
PropertyParser x =>
CSSGrid
-> Font'
-> [CSSCell]
-> [LayoutItem Length Length x]
-> LayoutItem Length Length x
finalizeGrid self :: CSSGrid
self@CSSGrid {
        templateColumns :: CSSGrid -> [([Text], Unitted)]
templateColumns = [([Text], Unitted)]
cols', templateRows :: CSSGrid -> [([Text], Unitted)]
templateRows = [([Text], Unitted)]
rows'
    } Font'
font [CSSCell]
cells [LayoutItem Length Length x]
childs = forall m n x.
x
-> Grid m n -> [GridItem] -> [LayoutItem m n x] -> LayoutItem m n x
LayoutGrid forall a. PropertyParser a => a
temp Size (Track Length) (Track Length)
self' [GridItem]
cells' [LayoutItem Length Length x]
childs
  where
    self' :: Size (Track Length) (Track Length)
self' = forall m n. n -> m -> Size m n
Size Track {
        cells :: [Either Length Double]
cells = forall a b. (a -> b) -> [a] -> [b]
map Unitted -> Either Length Double
finalizeFR forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd [([Text], Unitted)]
rows0,
        trackMins :: [Double]
trackMins = [], trackNats :: [Double]
trackNats = [],
        gap :: Length
gap = Unitted -> Font' -> Length
finalizeLength (forall m n. Size m n -> n
inline forall a b. (a -> b) -> a -> b
$ CSSGrid -> Size Unitted Unitted
cssGap CSSGrid
self) Font'
font
      } Track {
        cells :: [Either Length Double]
cells = forall a b. (a -> b) -> [a] -> [b]
map Unitted -> Either Length Double
finalizeFR forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd [([Text], Unitted)]
cols0,
        trackMins :: [Double]
trackMins = [], trackNats :: [Double]
trackNats = [],
        gap :: Length
gap = Unitted -> Font' -> Length
finalizeLength (forall m n. Size m n -> m
block forall a b. (a -> b) -> a -> b
$ CSSGrid -> Size Unitted Unitted
cssGap CSSGrid
self) Font'
font
      }

    ([GridItem]
cells', [([Text], Unitted)]
rows0, [([Text], Unitted)]
cols0) = [CSSCell]
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> ([GridItem], [([Text], Unitted)], [([Text], Unitted)])
finalizeCells [CSSCell]
cells [([Text], Unitted)]
rows' [([Text], Unitted)]
cols'
    finalizeCells :: [CSSCell] -> [([Text], Unitted)] -> [([Text], Unitted)] ->
            ([GridItem], [([Text], Unitted)], [([Text], Unitted)])
    finalizeCells :: [CSSCell]
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> ([GridItem], [([Text], Unitted)], [([Text], Unitted)])
finalizeCells (CSSCell
cell:[CSSCell]
cells) [([Text], Unitted)]
rows [([Text], Unitted)]
cols = (GridItem
cell'forall a. a -> [a] -> [a]
:[GridItem]
cells', [([Text], Unitted)]
rows_, [([Text], Unitted)]
cols_)
      where
        (GridItem
cell', [([Text], Unitted)]
rows0, [([Text], Unitted)]
cols0) = CSSCell
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> (GridItem, [([Text], Unitted)], [([Text], Unitted)])
finalizeCell CSSCell
cell [([Text], Unitted)]
rows [([Text], Unitted)]
cols
        ([GridItem]
cells', [([Text], Unitted)]
rows_, [([Text], Unitted)]
cols_) = [CSSCell]
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> ([GridItem], [([Text], Unitted)], [([Text], Unitted)])
finalizeCells [CSSCell]
cells [([Text], Unitted)]
rows0 [([Text], Unitted)]
cols0
    finalizeCells [] [([Text], Unitted)]
rows [([Text], Unitted)]
cols = ([], [([Text], Unitted)]
rows, [([Text], Unitted)]
cols)
    finalizeCell :: CSSCell -> [([Text], Unitted)] -> [([Text], Unitted)] ->
            (GridItem, [([Text], Unitted)], [([Text], Unitted)])
    finalizeCell :: CSSCell
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> (GridItem, [([Text], Unitted)], [([Text], Unitted)])
finalizeCell cell :: CSSCell
cell@CSSCell {
            rowStart :: CSSCell -> Placement
rowStart = Placement
Autoplace, columnStart :: CSSCell -> Placement
columnStart = Placement
Autoplace
        } [([Text], Unitted)]
rows [([Text], Unitted)]
cols | CSSGrid -> Axis
autoFlow CSSGrid
self forall a. Eq a => a -> a -> Bool
== Axis
Row =
            CSSCell
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> (GridItem, [([Text], Unitted)], [([Text], Unitted)])
finalizeCell CSSCell
cell { columnStart :: Placement
columnStart = Int -> Maybe Text -> Placement
Numbered Int
1 forall a. Maybe a
Nothing } [([Text], Unitted)]
rows [([Text], Unitted)]
cols
        | CSSGrid -> Axis
autoFlow CSSGrid
self forall a. Eq a => a -> a -> Bool
== Axis
Col =
            CSSCell
-> [([Text], Unitted)]
-> [([Text], Unitted)]
-> (GridItem, [([Text], Unitted)], [([Text], Unitted)])
finalizeCell CSSCell
cell { rowStart :: Placement
rowStart = Int -> Maybe Text -> Placement
Numbered Int
1 forall a. Maybe a
Nothing } [([Text], Unitted)]
rows [([Text], Unitted)]
cols
    finalizeCell CSSCell
cell [([Text], Unitted)]
rows [([Text], Unitted)]
cols = (forall m n. n -> m -> Size m n
Size GridItem {
            cellStart :: Int
cellStart = Int
startCol', cellEnd :: Int
cellEnd = Int
endCol',
            minSize :: Double
minSize = Double
0, natSize :: Double
natSize = Double
0,
            alignment :: Alignment
alignment = forall a. a -> Maybe a -> a
fromMaybe (forall m n. Size m n -> n
inline forall a b. (a -> b) -> a -> b
$ CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) (forall m n. Size m n -> n
inline forall a b. (a -> b) -> a -> b
$ CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
cell)
        } GridItem {
            cellStart :: Int
cellStart = Int
startRow', cellEnd :: Int
cellEnd = Int
endRow',
            minSize :: Double
minSize = Double
0, natSize :: Double
natSize = Double
0,
            alignment :: Alignment
alignment = forall a. a -> Maybe a -> a
fromMaybe (forall m n. Size m n -> n
inline forall a b. (a -> b) -> a -> b
$ CSSGrid -> Size Alignment Alignment
alignItems CSSGrid
self) (forall m n. Size m n -> n
inline forall a b. (a -> b) -> a -> b
$ CSSCell -> Size (Maybe Alignment) (Maybe Alignment)
alignSelf CSSCell
cell)
        }, [([Text], Unitted)]
rows', [([Text], Unitted)]
cols')
      where
        (Int
startRow', Int
endRow', [([Text], Unitted)]
rows') = forall {b}.
[([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], Unitted)]
rows ([], CSSGrid -> Unitted
autoRows CSSGrid
self)
                (CSSCell -> Placement
rowStart CSSCell
cell) (CSSCell -> Placement
rowEnd CSSCell
cell)
        (Int
startCol', Int
endCol', [([Text], Unitted)]
cols') = forall {b}.
[([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], Unitted)]
cols ([], CSSGrid -> Unitted
autoColumns CSSGrid
self) 
                (CSSCell -> Placement
columnStart CSSCell
cell) (CSSCell -> Placement
columnEnd CSSCell
cell)

    lowerTrack2 :: [([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], b)]
tracks ([Text], b)
auto Placement
start Placement
Autoplace = [([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], b)]
tracks ([Text], b)
auto Placement
start forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Span Int
1 forall a. Maybe a
Nothing
    lowerTrack2 [([Text], b)]
tracks ([Text], b)
auto start :: Placement
start@(Span Int
_ Maybe Text
_) end :: Placement
end@(Span Int
_ Maybe Text
_) =
        [([Text], b)]
-> ([Text], b)
-> Placement
-> Placement
-> (Int, Int, [([Text], b)])
lowerTrack2 [([Text], b)]
tracks ([Text], b)
auto Placement
start forall a b. (a -> b) -> a -> b
$ Int -> Maybe Text -> Placement
Numbered (forall a. Enum a => a -> a
pred forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Text], b)]
tracks) forall a. Maybe a
Nothing
    lowerTrack2 [([Text], b)]
tracks ([Text], b)
auto start :: Placement
start@(Span Int
_ Maybe Text
_) Placement
end = (Int
start', Int
end', [([Text], b)]
tracks')
      where
        (Int
end', [([Text], b)]
tracks0) = forall {b}.
[([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto Int
0 Placement
end -- Already checked for spans.
        (Int
start', [([Text], b)]
tracks') = forall {b}.
[([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto (forall a. Num a => a -> a
negate Int
end') Placement
start
    lowerTrack2 [([Text], b)]
tracks ([Text], b)
auto Placement
start Placement
end = (Int
start', Int
end', [([Text], b)]
tracks')
      where
        (Int
start', [([Text], b)]
tracks0) = forall {b}.
[([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto Int
0 Placement
start -- already checked for spans.
        (Int
end', [([Text], b)]
tracks') = forall {b}.
[([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto Int
start' Placement
end
    lowerTrack :: [([Text], b)]
-> ([Text], b) -> Int -> Placement -> (Int, [([Text], b)])
lowerTrack [([Text], b)]
tracks ([Text], b)
auto Int
_ (Named Text
name)
        | Int
ix:[Int]
_ <- [Int
ix | (Int
ix, ([Text]
names, b
_)) <- forall {b}. [b] -> [(Int, b)]
enumerate [([Text], b)]
tracks, Text
name forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
names] = (Int
ix, [([Text], b)]
tracks)
        | Bool
otherwise = (forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Text], b)]
tracks, [([Text], b)]
tracks forall a. [a] -> [a] -> [a]
++ [([Text], b)
auto])

    -- TODO Take into account placement strategy.
    lowerTrack [([Text], b)]
tracks ([Text], b)
auto Int
_ Placement
Autoplace = (forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Text], b)]
tracks, [([Text], b)]
tracks forall a. [a] -> [a] -> [a]
++ [([Text], b)
auto])
    lowerTrack [([Text], b)]
tracks ([Text], b)
_ Int
_ (Numbered Int
ix Maybe Text
Nothing) = (Int
ix, [([Text], b)]
tracks)
    lowerTrack [([Text], b)]
tracks ([Text], b)
auto Int
_ (Numbered Int
ix (Just Text
name))
        | Int
ix forall a. Ord a => a -> a -> Bool
< forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
tracks' = ([Int]
tracks' forall a. [a] -> Int -> a
!! Int
ix, [([Text], b)]
tracks)
        | Bool
otherwise = (forall (t :: * -> *) a. Foldable t => t a -> Int
length [([Text], b)]
tracks, [([Text], b)]
tracks forall a. [a] -> [a] -> [a]
++ [([Text], b)
auto])
      where tracks' :: [Int]
tracks' = [Int
ix | (Int
ix, ([Text]
names, b
_)) <- forall {b}. [b] -> [(Int, b)]
enumerate [([Text], b)]
tracks, Text
name forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
names]
    lowerTrack [([Text], b)]
tracks ([Text], b)
_ Int
start (Span Int
x Maybe Text
Nothing)
        | Int
start forall a. Ord a => a -> a -> Bool
> Int
0 = (Int
start forall a. Num a => a -> a -> a
+ Int
x,[([Text], b)]
tracks)
        | Bool
otherwise = (-Int
start forall a. Num a => a -> a -> a
- Int
x,[([Text], b)]
tracks)
    lowerTrack [([Text], b)]
tracks ([Text]
_, b
auto) Int
start (Span Int
x (Just Text
name)) = ([Int]
tracks' forall a. [a] -> Int -> a
!! Int
x,[([Text], b)]
tracks)
      where
        tracks0 :: [([Text], b)]
tracks0 | Int
start forall a. Ord a => a -> a -> Bool
< Int
0 = forall a. [a] -> [a]
reverse [([Text], b)]
tracks
            | Bool
otherwise = [([Text], b)]
tracks
        tracks' :: [Int]
tracks' = [Int
ix | (Int
ix, ([Text]
names, b
_)) <-
            forall a. Int -> [a] -> [a]
drop (forall a. Num a => a -> a
abs Int
start) forall a b. (a -> b) -> a -> b
$ forall {b}. [b] -> [(Int, b)]
enumerate ([([Text], b)]
tracks0 forall a. [a] -> [a] -> [a]
++ forall a. a -> [a]
repeat ([Text
name],b
auto)),
            Text
name forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
names]

    finalizeFR :: Unitted -> Either Length Double
finalizeFR (Double
x,Text
"fr") = forall a b. b -> Either a b
Right Double
x
    finalizeFR Unitted
x = forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ Unitted -> Font' -> Length
finalizeLength Unitted
x Font'
font