{-# LANGUAGE OverloadedStrings #-}
module Graphics.Layout.CSS.Parse (
    CSSBox(..), direction, txtOpts, BoxSizing(..), Display(..)) where
import Data.CSS.Syntax.Tokens (Token(..), NumericValue(..))
import Stylist (PropertyParser(..), TrivialPropertyParser, parseOperands,
                parseUnorderedShorthand', parseUnorderedShorthand)
import Data.Text.ParagraphLayout (PageOptions(..))
import Data.Text.ParagraphLayout.Rich (textDirection, ParagraphOptions,
            defaultParagraphOptions, paragraphAlignment, ParagraphAlignment(..))
import Data.Text.Glyphize (Direction(..))

import Graphics.Layout.Box as B
import Graphics.Text.Font.Choose (Pattern, unset)
import Graphics.Layout.CSS.Length (Unitted, parseLength', parseLength, auto, units)
import Graphics.Layout.CSS.Font (CSSFont)
import Graphics.Layout.Grid.CSS (CSSGrid(..), CSSCell(..), Placement(..))
import Graphics.Layout.Grid.Table (TableOptions)
import Graphics.Layout.Inline.CSS (CSSInline(..))
import Graphics.Layout.Flex.CSS (CSSFlex(..))

import Data.Maybe (isJust, fromMaybe)
import Text.Read (readMaybe)
import qualified Data.HashMap.Lazy as HM
import Data.Text (Text, unpack)
import Debug.Trace (trace) -- For debug warnings.

-- | Parsed CSS properties relevant to layout.
data CSSBox a = CSSBox {
    -- | Which layout formula to use, a.k.a. parsed CSS display property.
    forall a. CSSBox a -> Display
display :: Display,
    -- | (Unused) Parsed CSS box-sizing
    forall a. CSSBox a -> BoxSizing
boxSizing :: BoxSizing,
    -- | sizing, margins, border-width, & padding CSS properties.
    -- Stores units in case they're needed for font-related units.
    forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox :: PaddedBox Unitted Unitted, -- calc()?
    -- | Query parameters describing desired font.
    forall a. CSSBox a -> Pattern
font :: Pattern,
    -- | Additional font-related CSS properties.
    forall a. CSSBox a -> CSSFont
font' :: CSSFont,
    -- | Caller-specified data, to parse additional CSS properties.
    forall a. CSSBox a -> a
inner :: a,
    -- | Properties to lower size units before passing onto to `inner`
    forall a. CSSBox a -> [(Text, [Token])]
innerProperties :: [(Text, [Token])],
    -- | Parent to use when parsing length-expanded inner properties.
    forall a. CSSBox a -> a
innerParent :: a,
    -- | Grid-related CSS properties.
    forall a. CSSBox a -> CSSGrid
gridStyles :: CSSGrid,
    -- | Grid item related CSS properties.
    forall a. CSSBox a -> CSSCell
cellStyles :: CSSCell,
    -- | inline-related CSS properties.
    forall a. CSSBox a -> CSSInline
inlineStyles :: CSSInline,
    -- | Parsed widows & orphans controlling pagination.
    forall a. CSSBox a -> PageOptions
pageOptions :: PageOptions,
    -- | Parsed text-alignment & other options which applies per-paragraph.
    forall a. CSSBox a -> ParagraphOptions
paragraphOptions :: ParagraphOptions,
    -- | (Semi-)parsed CSS properties & HTML attributes relating to laying out
    -- HTML table elements.
    forall a. CSSBox a -> TableOptions
tableOptions :: TableOptions,
    -- | Semi-parsed CSS properties relating to FlexBox layouts.
    forall a. CSSBox a -> CSSFlex
flexOptions :: CSSFlex
}
-- | FlexOptions getter with `textLTR` set
flexOpts' :: CSSBox a -> CSSFlex
flexOpts' self :: CSSBox a
self@CSSBox { flexOptions :: forall a. CSSBox a -> CSSFlex
flexOptions = CSSFlex
ret } = CSSFlex
ret { textRTL :: Bool
textRTL = forall {a}. CSSBox a -> Direction
direction CSSBox a
self forall a. Eq a => a -> a -> Bool
== Direction
DirRTL }
-- | Accessor for inlineStyle's `textDirection` attribute.
direction :: CSSBox a -> Direction
direction CSSBox { inlineStyles :: forall a. CSSBox a -> CSSInline
inlineStyles = CSSInline Text
_ TextOptions
opts UnicodeBidi
_ } = TextOptions -> Direction
textDirection TextOptions
opts
-- | Accessor for inlineStyle's options.
txtOpts :: CSSBox a -> TextOptions
txtOpts CSSBox { inlineStyles :: forall a. CSSBox a -> CSSInline
inlineStyles = CSSInline Text
_ TextOptions
opts UnicodeBidi
_ } = TextOptions
opts
-- | Possible values for CSS box-sizing.
data BoxSizing = BorderBox | ContentBox
-- | Empty border, to use as default value.
noborder :: Border Unitted Unitted
noborder = forall m n. m -> m -> n -> n -> Border m n
Border (Double
0,Text
"px") (Double
0,Text
"px") (Double
0,Text
"px") (Double
0,Text
"px")

-- | Possibly values for CSS display property.
data Display = Block | Grid | Inline | Table | None |
    TableRow | TableHeaderGroup | TableRowGroup | TableFooterGroup | TableCell |
    TableColumn | TableColumnGroup | TableCaption | Flex deriving Display -> Display -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Display -> Display -> Bool
$c/= :: Display -> Display -> Bool
== :: Display -> Display -> Bool
$c== :: Display -> Display -> Bool
Eq
-- | Can the display value contain table-rows?
rowContainer :: CSSBox a -> Bool
rowContainer CSSBox { display :: forall a. CSSBox a -> Display
display = Display
d } =
    Display
d forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Display
Table, Display
TableHeaderGroup, Display
TableRowGroup, Display
TableFooterGroup]

instance PropertyParser a => PropertyParser (CSSBox a) where
    temp :: CSSBox a
temp = CSSBox {
        boxSizing :: BoxSizing
boxSizing = BoxSizing
ContentBox,
        display :: Display
display = Display
Inline,
        cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox {
            min :: Size Unitted Unitted
B.min = forall m n. n -> m -> Size m n
Size Unitted
auto Unitted
auto,
            size :: Size Unitted Unitted
size = forall m n. n -> m -> Size m n
Size Unitted
auto Unitted
auto,
            nat :: Size Double Double
nat = forall m n. n -> m -> Size m n
Size Double
0 Double
0,
            max :: Size Unitted Unitted
B.max = forall m n. n -> m -> Size m n
Size Unitted
auto Unitted
auto,
            padding :: Border Unitted Unitted
padding = Border Unitted Unitted
noborder,
            border :: Border Unitted Unitted
border = Border Unitted Unitted
noborder,
            margin :: Border Unitted Unitted
margin = Border Unitted Unitted
noborder
        },
        font :: Pattern
font = forall a. PropertyParser a => a
temp,
        font' :: CSSFont
font' = forall a. PropertyParser a => a
temp,
        inner :: a
inner = forall a. PropertyParser a => a
temp,
        innerProperties :: [(Text, [Token])]
innerProperties = [],
        innerParent :: a
innerParent = forall a. [Char] -> a -> a
trace ([Char]
"Parent not overriden upon " forall a. [a] -> [a] -> [a]
++
            [Char]
"buffering inner properties for length resolution!") forall a. PropertyParser a => a
temp,
        gridStyles :: CSSGrid
gridStyles = forall a. PropertyParser a => a
temp,
        cellStyles :: CSSCell
cellStyles = forall a. PropertyParser a => a
temp,
        inlineStyles :: CSSInline
inlineStyles = forall a. PropertyParser a => a
temp,
        pageOptions :: PageOptions
pageOptions = Int32 -> Int32 -> Word -> Word -> PageOptions
PageOptions Int32
0 Int32
0 Word
2 Word
2,
        paragraphOptions :: ParagraphOptions
paragraphOptions = ParagraphOptions
defaultParagraphOptions {
            paragraphAlignment :: ParagraphAlignment
paragraphAlignment = ParagraphAlignment
AlignStart
        },
        tableOptions :: TableOptions
tableOptions = forall a. PropertyParser a => a
temp,
        flexOptions :: CSSFlex
flexOptions = forall a. PropertyParser a => a
temp
      }
    inherit :: CSSBox a -> CSSBox a
inherit CSSBox a
parent = CSSBox {
        boxSizing :: BoxSizing
boxSizing = forall a. CSSBox a -> BoxSizing
boxSizing CSSBox a
parent,
        display :: Display
display = Display
Inline,
        cssBox :: PaddedBox Unitted Unitted
cssBox = forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox (forall a. PropertyParser a => a
temp :: CSSBox TrivialPropertyParser),
        font :: Pattern
font = forall a. PropertyParser a => a -> a
inherit forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> Pattern
font CSSBox a
parent,
        font' :: CSSFont
font' = forall a. PropertyParser a => a -> a
inherit forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> CSSFont
font' CSSBox a
parent,
        inner :: a
inner = forall a. PropertyParser a => a -> a
inherit forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> a
inner CSSBox a
parent,
        innerProperties :: [(Text, [Token])]
innerProperties = [],
        innerParent :: a
innerParent = forall a. CSSBox a -> a
inner CSSBox a
parent,
        gridStyles :: CSSGrid
gridStyles = forall a. PropertyParser a => a -> a
inherit forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> CSSGrid
gridStyles CSSBox a
parent,
        cellStyles :: CSSCell
cellStyles = forall a. PropertyParser a => a -> a
inherit forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> CSSCell
cellStyles CSSBox a
parent,
        inlineStyles :: CSSInline
inlineStyles = forall a. PropertyParser a => a -> a
inherit forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> CSSInline
inlineStyles CSSBox a
parent,
        pageOptions :: PageOptions
pageOptions = forall a. CSSBox a -> PageOptions
pageOptions CSSBox a
parent,
        paragraphOptions :: ParagraphOptions
paragraphOptions = forall a. CSSBox a -> ParagraphOptions
paragraphOptions CSSBox a
parent,
        tableOptions :: TableOptions
tableOptions = forall a. PropertyParser a => a -> a
inherit forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> TableOptions
tableOptions CSSBox a
parent,
        flexOptions :: CSSFlex
flexOptions = forall a. PropertyParser a => a -> a
inherit forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> CSSFlex
flexOptions CSSBox a
parent
      }
    priority :: CSSBox a -> [Text]
priority CSSBox a
self = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [forall {a}. PropertyParser a => (CSSBox a -> a) -> [Text]
x forall a. CSSBox a -> CSSInline
inlineStyles, forall {a}. PropertyParser a => (CSSBox a -> a) -> [Text]
x forall a. CSSBox a -> Pattern
font, forall {a}. PropertyParser a => (CSSBox a -> a) -> [Text]
x forall a. CSSBox a -> CSSFont
font', forall {a}. PropertyParser a => (CSSBox a -> a) -> [Text]
x forall a. CSSBox a -> CSSGrid
gridStyles,
        forall {a}. PropertyParser a => (CSSBox a -> a) -> [Text]
x forall a. CSSBox a -> CSSCell
cellStyles, forall {a}. PropertyParser a => (CSSBox a -> a) -> [Text]
x forall a. CSSBox a -> CSSFlex
flexOptions, forall {a}. PropertyParser a => (CSSBox a -> a) -> [Text]
x forall a. CSSBox a -> a
inner]
      where x :: (CSSBox a -> a) -> [Text]
x CSSBox a -> a
getter = forall a. PropertyParser a => a -> [Text]
priority forall a b. (a -> b) -> a -> b
$ CSSBox a -> a
getter CSSBox a
self

    -- Wasn't sure how to implement in FontConfig-Pure
    longhand :: CSSBox a -> CSSBox a -> Text -> [Token] -> Maybe (CSSBox a)
longhand CSSBox a
_ CSSBox a
self Text
"font-family" [Ident Text
"initial"] =
        forall a. a -> Maybe a
Just CSSBox a
self { font :: Pattern
font = forall {a} {b}. Eq a => a -> [(a, b)] -> [(a, b)]
unset [Char]
"family" forall a b. (a -> b) -> a -> b
$ forall a. CSSBox a -> Pattern
font CSSBox a
self}

    longhand CSSBox a
_ CSSBox a
self Text
"box-sizing" [Ident Text
"content-box"] = forall a. a -> Maybe a
Just CSSBox a
self {boxSizing :: BoxSizing
boxSizing = BoxSizing
ContentBox}
    longhand CSSBox a
_ CSSBox a
self Text
"box-sizing" [Ident Text
"border-box"] = forall a. a -> Maybe a
Just CSSBox a
self {boxSizing :: BoxSizing
boxSizing = BoxSizing
BorderBox}
    longhand CSSBox a
_ CSSBox a
self Text
"box-sizing" [Ident Text
"initial"] = forall a. a -> Maybe a
Just CSSBox a
self {boxSizing :: BoxSizing
boxSizing = BoxSizing
ContentBox}

    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"padding-top" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { padding :: Border Unitted Unitted
padding = (forall m n. PaddedBox m n -> Border m n
padding PaddedBox Unitted Unitted
box) { top :: Unitted
top = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"padding-bottom" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { padding :: Border Unitted Unitted
padding = (forall m n. PaddedBox m n -> Border m n
padding PaddedBox Unitted Unitted
box) { bottom :: Unitted
bottom = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"padding-left" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { padding :: Border Unitted Unitted
padding = (forall m n. PaddedBox m n -> Border m n
padding PaddedBox Unitted Unitted
box) { left :: Unitted
left = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"padding-right" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { padding :: Border Unitted Unitted
padding = (forall m n. PaddedBox m n -> Border m n
padding PaddedBox Unitted Unitted
box) { right :: Unitted
right = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"padding-inline-start" [Token]
toks
        | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks, Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self =
            forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { padding :: Border Unitted Unitted
padding = (forall m n. PaddedBox m n -> Border m n
padding PaddedBox Unitted Unitted
box) { left :: Unitted
left = Unitted
x } } }
        | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks, Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self =
            forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { padding :: Border Unitted Unitted
padding = (forall m n. PaddedBox m n -> Border m n
padding PaddedBox Unitted Unitted
box) { right :: Unitted
right = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"padding-inline-end" [Token]
toks
        | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks, Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self =
            forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { padding :: Border Unitted Unitted
padding = (forall m n. PaddedBox m n -> Border m n
padding PaddedBox Unitted Unitted
box) { right :: Unitted
right = Unitted
x } } }
        | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks, Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self =
            forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { padding :: Border Unitted Unitted
padding = (forall m n. PaddedBox m n -> Border m n
padding PaddedBox Unitted Unitted
box) { left :: Unitted
left = Unitted
x } } }

    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"border-top-width" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { border :: Border Unitted Unitted
border = (forall m n. PaddedBox m n -> Border m n
border PaddedBox Unitted Unitted
box) { top :: Unitted
top = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"border-bottom-width" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { border :: Border Unitted Unitted
border = (forall m n. PaddedBox m n -> Border m n
border PaddedBox Unitted Unitted
box) { bottom :: Unitted
bottom = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"border-left-width" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { border :: Border Unitted Unitted
border = (forall m n. PaddedBox m n -> Border m n
border PaddedBox Unitted Unitted
box) { left :: Unitted
left = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"border-right-width" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { border :: Border Unitted Unitted
border = (forall m n. PaddedBox m n -> Border m n
border PaddedBox Unitted Unitted
box) { right :: Unitted
right = Unitted
x } } }
    longhand CSSBox a
p CSSBox a
self Text
"border-inline-start-color" [Token]
toks
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-left-color" [Token]
toks
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-right-color" [Token]
toks
    longhand CSSBox a
p CSSBox a
self Text
"border-inline-start-width" [Token]
toks
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-left-width" [Token]
toks
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-right-width" [Token]
toks
    longhand CSSBox a
p CSSBox a
self Text
"border-inline-start-style" [Token]
toks
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-left-style" [Token]
toks
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-right-style" [Token]
toks
    longhand CSSBox a
p CSSBox a
self Text
"border-inline-end-color" [Token]
toks
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-right-color" [Token]
toks
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-left-color" [Token]
toks
    longhand CSSBox a
p CSSBox a
self Text
"border-inline-end-width" [Token]
toks
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-right-width" [Token]
toks
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-left-width" [Token]
toks
    longhand CSSBox a
p CSSBox a
self Text
"border-inline-end-style" [Token]
toks
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-right-style" [Token]
toks
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-left-style" [Token]
toks
    longhand CSSBox a
p CSSBox a
self Text
"border-start-start-radius" [Token]
t
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-top-left-radius" [Token]
t
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-top-right-radius" [Token]
t
    longhand CSSBox a
p CSSBox a
self Text
"border-start-end-radius" [Token]
t
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-top-right-radius" [Token]
t
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-top-left-radius" [Token]
t
    longhand CSSBox a
p CSSBox a
s Text
"border-end-start-radius" [Token]
t
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
s = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
s Text
"border-bottom-left-radius" [Token]
t
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
s = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
s Text
"border-bottom-right-radius" [Token]
t
    longhand CSSBox a
p CSSBox a
s Text
"border-end-end-radius" [Token]
t
        | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
s = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
s Text
"border-bottom-right-radius" [Token]
t
        | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
s = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
s Text
"border-bottom-left-radius" [Token]
t

    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"margin-top" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { margin :: Border Unitted Unitted
margin = (forall m n. PaddedBox m n -> Border m n
margin PaddedBox Unitted Unitted
box) { top :: Unitted
top = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"margin-bottom" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { margin :: Border Unitted Unitted
margin = (forall m n. PaddedBox m n -> Border m n
margin PaddedBox Unitted Unitted
box) { bottom :: Unitted
bottom = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"margin-left" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { margin :: Border Unitted Unitted
margin = (forall m n. PaddedBox m n -> Border m n
margin PaddedBox Unitted Unitted
box) { left :: Unitted
left = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"margin-right" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { margin :: Border Unitted Unitted
margin = (forall m n. PaddedBox m n -> Border m n
margin PaddedBox Unitted Unitted
box) { right :: Unitted
right = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"margin-inline-start" [Token]
toks
        | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks, Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self =
            forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { margin :: Border Unitted Unitted
margin = (forall m n. PaddedBox m n -> Border m n
margin PaddedBox Unitted Unitted
box) { left :: Unitted
left = Unitted
x } } }
        | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks, Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self =
            forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { margin :: Border Unitted Unitted
margin = (forall m n. PaddedBox m n -> Border m n
margin PaddedBox Unitted Unitted
box) { right :: Unitted
right = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"margin-inline-end" [Token]
toks
        | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks, Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self =
            forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { margin :: Border Unitted Unitted
margin = (forall m n. PaddedBox m n -> Border m n
margin PaddedBox Unitted Unitted
box) { right :: Unitted
right = Unitted
x } } }
        | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength [Token]
toks, Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
self =
            forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { margin :: Border Unitted Unitted
margin = (forall m n. PaddedBox m n -> Border m n
margin PaddedBox Unitted Unitted
box) { left :: Unitted
left = Unitted
x } } }

    -- Placeholder implementations until vertical text is implemented.
    longhand CSSBox a
p CSSBox a
self Text
"padding-block-start" [Token]
t = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"padding-top" [Token]
t
    longhand CSSBox a
p CSSBox a
self Text
"padding-block-end" [Token]
t = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"padding-bottom" [Token]
t
    longhand CSSBox a
p CSSBox a
self Text
"margin-block-start" [Token]
t = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"margin-top" [Token]
t
    longhand CSSBox a
p CSSBox a
self Text
"margin-block-end" [Token]
t = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"margin-bottom" [Token]
t
    longhand CSSBox a
p CSSBox a
self Text
"border-block-start-color" [Token]
toks =
        forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-top-color" [Token]
toks
    longhand CSSBox a
p CSSBox a
self Text
"border-block-start-style" [Token]
toks =
        forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-top-style" [Token]
toks
    longhand CSSBox a
p CSSBox a
self Text
"border-block-start-width" [Token]
toks =
        forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
self Text
"border-top-width" [Token]
toks
    longhand CSSBox a
p CSSBox a
s Text
"border-block-end-color" [Token]
t = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
s Text
"border-bottom-color" [Token]
t
    longhand CSSBox a
p CSSBox a
s Text
"border-block-end-style" [Token]
t = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
s Text
"border-bottom-style" [Token]
t
    longhand CSSBox a
p CSSBox a
s Text
"border-block-end-width" [Token]
t = forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
p CSSBox a
s Text
"border-bottom-width" [Token]
t

    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"width" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength' [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { size :: Size Unitted Unitted
size = (forall m n. PaddedBox m n -> Size m n
size PaddedBox Unitted Unitted
box) { inline :: Unitted
inline = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"height" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength' [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { size :: Size Unitted Unitted
size = (forall m n. PaddedBox m n -> Size m n
size PaddedBox Unitted Unitted
box) { block :: Unitted
block = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"max-width" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength' [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { max :: Size Unitted Unitted
B.max = (forall m n. PaddedBox m n -> Size m n
B.max PaddedBox Unitted Unitted
box) { inline :: Unitted
inline = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"min-width" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength' [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { min :: Size Unitted Unitted
B.min = (forall m n. PaddedBox m n -> Size m n
B.min PaddedBox Unitted Unitted
box) { inline :: Unitted
inline = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"max-height" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength' [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { max :: Size Unitted Unitted
B.max = (forall m n. PaddedBox m n -> Size m n
B.max PaddedBox Unitted Unitted
box) { block :: Unitted
block = Unitted
x } } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {cssBox :: forall a. CSSBox a -> PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box} Text
"min-height" [Token]
toks | Just Unitted
x <- [Token] -> Maybe Unitted
parseLength' [Token]
toks =
        forall a. a -> Maybe a
Just CSSBox a
self { cssBox :: PaddedBox Unitted Unitted
cssBox = PaddedBox Unitted Unitted
box { min :: Size Unitted Unitted
B.min = (forall m n. PaddedBox m n -> Size m n
B.min PaddedBox Unitted Unitted
box) { block :: Unitted
block = Unitted
x } } }

    longhand CSSBox a
_ CSSBox a
self Text
"display" [Ident Text
"block"] = forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
Block }
    longhand CSSBox a
_ CSSBox a
self Text
"display" [Ident Text
"none"] = forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
None }
    longhand CSSBox a
_ CSSBox a
self Text
"display" [Ident Text
"grid"] = forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
Grid }
    longhand CSSBox a
_ CSSBox a
self Text
"display" [Ident Text
"table"] = forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
Table }
    longhand CSSBox { display :: forall a. CSSBox a -> Display
display = Display
Table } CSSBox a
self Text
"display" [Ident Text
"table-row-group"] =
        forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display=Display
TableRowGroup }
    longhand CSSBox { display :: forall a. CSSBox a -> Display
display = Display
Table } CSSBox a
self Text
"display" [Ident Text
"table-header-group"] =
        forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
TableHeaderGroup }
    longhand CSSBox { display :: forall a. CSSBox a -> Display
display = Display
Table } CSSBox a
self Text
"display" [Ident Text
"table-footer-group"] =
        forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
TableFooterGroup }
    longhand CSSBox a
parent CSSBox a
self Text
"display" [Ident Text
"table-row"] | forall {a}. CSSBox a -> Bool
rowContainer CSSBox a
parent =
        forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
TableRow }
    longhand CSSBox { display :: forall a. CSSBox a -> Display
display = Display
TableRow } CSSBox a
self Text
"display" [Ident Text
"table-cell"] =
        forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
TableCell }
    longhand CSSBox { display :: forall a. CSSBox a -> Display
display = Display
Table } CSSBox a
self Text
"display" [Ident Text
"table-column-group"] =
        forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
TableColumnGroup }
    longhand CSSBox { display :: forall a. CSSBox a -> Display
display = Display
TableColumnGroup } CSSBox a
self Text
"display" [Ident Text
"table-column"] =
        forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
TableColumn }
    longhand CSSBox { display :: forall a. CSSBox a -> Display
display = Display
Table } CSSBox a
self Text
"display" [Ident Text
"table-caption"] =
        forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display=Display
TableCaption }
    longhand CSSBox a
_ CSSBox a
self Text
"display" [Ident Text
"inline"] = forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
Inline }
    longhand CSSBox a
_ CSSBox a
self Text
"display" [Ident Text
"flex"] = forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
Flex }
    longhand CSSBox a
_ CSSBox a
self Text
"display" [Ident Text
"initial"] = forall a. a -> Maybe a
Just CSSBox a
self { display :: Display
display = Display
Inline }

    longhand CSSBox a
_ CSSBox a
self Text
"orphans" [Number Text
_ (NVInteger Integer
x)] =
        forall a. a -> Maybe a
Just CSSBox a
self { pageOptions :: PageOptions
pageOptions = (forall a. CSSBox a -> PageOptions
pageOptions CSSBox a
self) { pageOrphans :: Word
pageOrphans = forall a. Num a => Integer -> a
fromInteger Integer
x } }
    longhand CSSBox a
_ CSSBox a
self Text
"widows" [Number Text
_ (NVInteger Integer
x)] =
        forall a. a -> Maybe a
Just CSSBox a
self { pageOptions :: PageOptions
pageOptions = (forall a. CSSBox a -> PageOptions
pageOptions CSSBox a
self) { pageWidows :: Word
pageWidows = forall a. Num a => Integer -> a
fromInteger Integer
x } }

    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {paragraphOptions :: forall a. CSSBox a -> ParagraphOptions
paragraphOptions=ParagraphOptions
o} Text
"text-align" [Ident Text
"initial"] =
        forall a. a -> Maybe a
Just CSSBox a
self { paragraphOptions :: ParagraphOptions
paragraphOptions = ParagraphOptions
o { paragraphAlignment :: ParagraphAlignment
paragraphAlignment = ParagraphAlignment
AlignStart } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {paragraphOptions :: forall a. CSSBox a -> ParagraphOptions
paragraphOptions=ParagraphOptions
o} Text
"text-align" [Ident Text
"start"] =
        forall a. a -> Maybe a
Just CSSBox a
self { paragraphOptions :: ParagraphOptions
paragraphOptions = ParagraphOptions
o { paragraphAlignment :: ParagraphAlignment
paragraphAlignment = ParagraphAlignment
AlignStart } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {paragraphOptions :: forall a. CSSBox a -> ParagraphOptions
paragraphOptions=ParagraphOptions
o} Text
"text-align" [Ident Text
"end"] =
        forall a. a -> Maybe a
Just CSSBox a
self { paragraphOptions :: ParagraphOptions
paragraphOptions = ParagraphOptions
o { paragraphAlignment :: ParagraphAlignment
paragraphAlignment = ParagraphAlignment
AlignEnd } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {paragraphOptions :: forall a. CSSBox a -> ParagraphOptions
paragraphOptions=ParagraphOptions
o} Text
"text-align" [Ident Text
"left"] =
        forall a. a -> Maybe a
Just CSSBox a
self { paragraphOptions :: ParagraphOptions
paragraphOptions = ParagraphOptions
o { paragraphAlignment :: ParagraphAlignment
paragraphAlignment = ParagraphAlignment
AlignLeft } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {paragraphOptions :: forall a. CSSBox a -> ParagraphOptions
paragraphOptions=ParagraphOptions
o} Text
"text-align" [Ident Text
"right"] =
        forall a. a -> Maybe a
Just CSSBox a
self { paragraphOptions :: ParagraphOptions
paragraphOptions = ParagraphOptions
o { paragraphAlignment :: ParagraphAlignment
paragraphAlignment = ParagraphAlignment
AlignRight } }
    longhand CSSBox a
_ self :: CSSBox a
self@CSSBox {paragraphOptions :: forall a. CSSBox a -> ParagraphOptions
paragraphOptions=ParagraphOptions
o} Text
"text-align" [Ident Text
"center"] =
        forall a. a -> Maybe a
Just CSSBox a
self { paragraphOptions :: ParagraphOptions
paragraphOptions = ParagraphOptions
o { paragraphAlignment :: ParagraphAlignment
paragraphAlignment = ParagraphAlignment
AlignCentreH } }
    -- text-align: justify is unimplemented.
    longhand CSSBox a
p self :: CSSBox a
self@CSSBox { paragraphOptions :: forall a. CSSBox a -> ParagraphOptions
paragraphOptions = ParagraphOptions
o } Text
"text-align"
            [Ident Text
"match-parent"] = case ParagraphOptions -> ParagraphAlignment
paragraphAlignmentforall a b. (a -> b) -> a -> b
$forall a. CSSBox a -> ParagraphOptions
paragraphOptions CSSBox a
p of
        ParagraphAlignment
AlignStart | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
p -> ParagraphAlignment -> Maybe (CSSBox a)
ret ParagraphAlignment
AlignLeft
        ParagraphAlignment
AlignStart | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
p -> ParagraphAlignment -> Maybe (CSSBox a)
ret ParagraphAlignment
AlignRight
        ParagraphAlignment
AlignEnd | Direction
DirLTR <- forall {a}. CSSBox a -> Direction
direction CSSBox a
p -> ParagraphAlignment -> Maybe (CSSBox a)
ret ParagraphAlignment
AlignRight
        ParagraphAlignment
AlignEnd | Direction
DirRTL <- forall {a}. CSSBox a -> Direction
direction CSSBox a
p -> ParagraphAlignment -> Maybe (CSSBox a)
ret ParagraphAlignment
AlignLeft
        ParagraphAlignment
x -> ParagraphAlignment -> Maybe (CSSBox a)
ret ParagraphAlignment
x
      where ret :: ParagraphAlignment -> Maybe (CSSBox a)
ret ParagraphAlignment
x = forall a. a -> Maybe a
Just CSSBox a
self { paragraphOptions :: ParagraphOptions
paragraphOptions = ParagraphOptions
o { paragraphAlignment :: ParagraphAlignment
paragraphAlignment = ParagraphAlignment
x } }

    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just Pattern
x <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> Pattern
font CSSBox a
a) (forall a. CSSBox a -> Pattern
font CSSBox a
b) Text
c [Token]
d,
        Just CSSFont
y <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSFont
font' CSSBox a
a) (forall a. CSSBox a -> CSSFont
font' CSSBox a
b) Text
c [Token]
d =
            forall a. a -> Maybe a
Just CSSBox a
b { font :: Pattern
font = Pattern
x, font' :: CSSFont
font' = CSSFont
y } -- Those properties can overlap!
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just Pattern
font' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> Pattern
font CSSBox a
a) (forall a. CSSBox a -> Pattern
font CSSBox a
b) Text
c [Token]
d = forall a. a -> Maybe a
Just CSSBox a
b {
        font :: Pattern
font = Pattern
font'
      }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just CSSFont
font <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSFont
font' CSSBox a
a) (forall a. CSSBox a -> CSSFont
font' CSSBox a
b) Text
c [Token]
d = forall a. a -> Maybe a
Just CSSBox a
b {
        font' :: CSSFont
font' = CSSFont
font
      }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just CSSInline
inline' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSInline
inlineStyles CSSBox a
a) (forall a. CSSBox a -> CSSInline
inlineStyles CSSBox a
b) Text
c [Token]
d =
        forall a. a -> Maybe a
Just CSSBox a
b { inlineStyles :: CSSInline
inlineStyles = CSSInline
inline' }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just CSSGrid
grid' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSGrid
gridStyles CSSBox a
a) (forall a. CSSBox a -> CSSGrid
gridStyles CSSBox a
b) Text
c [Token]
d,
            Just CSSFlex
flex' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSFlex
flexOpts' CSSBox a
a) (forall a. CSSBox a -> CSSFlex
flexOpts' CSSBox a
b) Text
c [Token]
d =
        forall a. a -> Maybe a
Just CSSBox a
b { gridStyles :: CSSGrid
gridStyles = CSSGrid
grid', flexOptions :: CSSFlex
flexOptions = CSSFlex
flex' }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just CSSCell
cell' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSCell
cellStyles CSSBox a
a) (forall a. CSSBox a -> CSSCell
cellStyles CSSBox a
b) Text
c [Token]
d,
            Just CSSFlex
flex' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSFlex
flexOpts' CSSBox a
a) (forall a. CSSBox a -> CSSFlex
flexOpts' CSSBox a
b) Text
c [Token]
d =
        forall a. a -> Maybe a
Just CSSBox a
b { cellStyles :: CSSCell
cellStyles = CSSCell
cell', flexOptions :: CSSFlex
flexOptions = CSSFlex
flex' }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just CSSGrid
grid' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSGrid
gridStyles CSSBox a
a) (forall a. CSSBox a -> CSSGrid
gridStyles CSSBox a
b) Text
c [Token]
d =
        forall a. a -> Maybe a
Just CSSBox a
b { gridStyles :: CSSGrid
gridStyles = CSSGrid
grid' }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just CSSCell
cell' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSCell
cellStyles CSSBox a
a) (forall a. CSSBox a -> CSSCell
cellStyles CSSBox a
b) Text
c [Token]
d =
        forall a. a -> Maybe a
Just CSSBox a
b { cellStyles :: CSSCell
cellStyles = CSSCell
cell' }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just TableOptions
table'<-forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> TableOptions
tableOptions CSSBox a
a) (forall a. CSSBox a -> TableOptions
tableOptions CSSBox a
b) Text
c [Token]
d
        = forall a. a -> Maybe a
Just CSSBox a
b { tableOptions :: TableOptions
tableOptions = TableOptions
table' }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just CSSFlex
flex' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> CSSFlex
flexOpts' CSSBox a
a) (forall a. CSSBox a -> CSSFlex
flexOpts' CSSBox a
b) Text
c [Token]
d =
        forall a. a -> Maybe a
Just CSSBox a
b { flexOptions :: CSSFlex
flexOptions = CSSFlex
flex' }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d
        | ([Token]
d', Token
_:[Token]
_)<-[Token] -> ([Token], [Token])
testLengthProp [Token]
d, Just a
_<-forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> a
inner CSSBox a
a) (forall a. CSSBox a -> a
inner CSSBox a
b) Text
c [Token]
d' =
            forall a. a -> Maybe a
Just CSSBox a
b {
                innerProperties :: [(Text, [Token])]
innerProperties = (Text
c, [Token]
d)forall a. a -> [a] -> [a]
:forall a. CSSBox a -> [(Text, [Token])]
innerProperties CSSBox a
b,
                innerParent :: a
innerParent = forall a. CSSBox a -> a
inner CSSBox a
a
            }
    longhand CSSBox a
a CSSBox a
b Text
c [Token]
d | Just a
inner' <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand (forall a. CSSBox a -> a
inner CSSBox a
a) (forall a. CSSBox a -> a
inner CSSBox a
b) Text
c [Token]
d = forall a. a -> Maybe a
Just CSSBox a
b {
        inner :: a
inner = a
inner'
      }

    -- Technically a grid shorthand, but we need parent data to parse it!
    longhand CSSBox { gridStyles :: forall a. CSSBox a -> CSSGrid
gridStyles = CSSGrid
parent } CSSBox a
self Text
"grid-area" [Ident Text
x]
        | Just ((Int
colS, Int
colE), (Int
rowS, Maybe Int
rowE)) <- Text
x forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
`HM.lookup` CSSGrid -> Areas
templateAreas CSSGrid
parent
            = forall a. a -> Maybe a
Just CSSBox a
self { cellStyles :: CSSCell
cellStyles = (forall a. CSSBox a -> CSSCell
cellStyles CSSBox a
self) {
                columnStart :: Placement
columnStart = Int -> Placement
p Int
colS,
                columnEnd :: Placement
columnEnd = Int -> Placement
p Int
colE,
                rowStart :: Placement
rowStart = Int -> Placement
p Int
rowS,
                rowEnd :: Placement
rowEnd = Int -> Placement
p forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a -> a
fromMaybe (forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ CSSGrid -> Areas
templateAreas CSSGrid
parent) Maybe Int
rowE
            }}
      where p :: Int -> Placement
p Int
x = Int -> Maybe Text -> Placement
Numbered Int
x forall a. Maybe a
Nothing

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

    shorthand :: CSSBox a -> Text -> [Token] -> [(Text, [Token])]
shorthand CSSBox a
self Text
"font" [Token]
toks = case [Token] -> [[Token]]
parseOperands [Token]
toks of
        ([Token]
a:[Token]
b:[Token]
c:[Token]
d:[[Token]]
toks') | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- [[Token]] -> [(Text, [Token])]
unordered [[Token]
a,[Token]
b,[Token]
c,[Token]
d] -> forall {a}.
IsString a =>
[(a, [Token])] -> [[Token]] -> [(a, [Token])]
inner [(Text, [Token])]
ret [[Token]]
toks'
        ([Token]
a:[Token]
b:[Token]
c:[[Token]]
toks') | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- [[Token]] -> [(Text, [Token])]
unordered [[Token]
a,[Token]
b,[Token]
c] -> forall {a}.
IsString a =>
[(a, [Token])] -> [[Token]] -> [(a, [Token])]
inner [(Text, [Token])]
ret [[Token]]
toks'
        ([Token]
a:[Token]
b:[[Token]]
toks') | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- [[Token]] -> [(Text, [Token])]
unordered [[Token]
a,[Token]
b] -> forall {a}.
IsString a =>
[(a, [Token])] -> [[Token]] -> [(a, [Token])]
inner [(Text, [Token])]
ret [[Token]]
toks'
        ([Token]
a:[[Token]]
toks') | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- [[Token]] -> [(Text, [Token])]
unordered [[Token]
a] -> forall {a}.
IsString a =>
[(a, [Token])] -> [[Token]] -> [(a, [Token])]
inner [(Text, [Token])]
ret [[Token]]
toks'
        [[Token]]
toks' -> forall {a}.
IsString a =>
[(a, [Token])] -> [[Token]] -> [(a, [Token])]
inner [] [[Token]]
toks'
      where
        unordered :: [[Token]] -> [(Text, [Token])]
unordered [[Token]]
operands = forall a.
PropertyParser a =>
a -> [Text] -> [[Token]] -> [(Text, [Token])]
parseUnorderedShorthand' CSSBox a
self [
            Text
"font-style", Text
"font-variant", Text
"font-weight", Text
"font-stretch"] [[Token]]
operands
        inner :: [(a, [Token])] -> [[Token]] -> [(a, [Token])]
inner [(a, [Token])]
ret ([Token]
size:[Delim Char
'/']:[Token]
height:[[Token]]
family)
            | Just CSSBox a
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
self CSSBox a
self Text
"font-size" [Token]
size,
              Just CSSBox a
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
self CSSBox a
self Text
"line-height" [Token]
height,
              Just CSSBox a
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
self CSSBox a
self Text
"font-family" forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Token]]
family =
                (a
"font-size", [Token]
size)forall a. a -> [a] -> [a]
:(a
"line-height", [Token]
height)forall a. a -> [a] -> [a]
:
                    (a
"font-family", forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Token]]
family)forall a. a -> [a] -> [a]
:[(a, [Token])]
ret
            | Bool
otherwise = []
        inner [(a, [Token])]
ret ([Token]
size:[[Token]]
family)
            | Just CSSBox a
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
self CSSBox a
self Text
"font-size" [Token]
size,
              Just CSSBox a
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
self CSSBox a
self Text
"font-family" forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Token]]
family =
                (a
"font-size", [Token]
size)forall a. a -> [a] -> [a]
:(a
"line-height", [Text -> Token
Ident Text
"initial"])forall a. a -> [a] -> [a]
:
                    (a
"font-family", forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Token]]
family)forall a. a -> [a] -> [a]
:[(a, [Token])]
ret
            | Bool
otherwise = []
        inner [(a, [Token])]
_ [[Token]]
_ = []
    shorthand CSSBox a
self Text
"margin" [Token]
toks
        | forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Token]]
x forall a. Ord a => a -> a -> Bool
> Int
0 Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Token]]
x forall a. Ord a => a -> a -> Bool
<= Int
4, forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (forall {a}. PropertyParser a => a -> Text -> [Token] -> Bool
validProp CSSBox a
self Text
"margin-top") [[Token]]
x,
            ([Token]
top:[Token]
right:[Token]
bottom:[Token]
left:[[Token]]
_) <- forall a. [a] -> [a]
cycle [[Token]]
x =
                [(Text
"margin-top", [Token]
top), (Text
"margin-right", [Token]
right),
                 (Text
"margin-bottom", [Token]
bottom), (Text
"margin-left", [Token]
left)]
      where x :: [[Token]]
x = [Token] -> [[Token]]
parseOperands [Token]
toks
    shorthand CSSBox a
self Text
"padding" [Token]
toks
        | forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Token]]
x forall a. Ord a => a -> a -> Bool
> Int
0 Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Token]]
x forall a. Ord a => a -> a -> Bool
<= Int
4, forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (forall {a}. PropertyParser a => a -> Text -> [Token] -> Bool
validProp CSSBox a
self Text
"padding-top") [[Token]]
x,
            ([Token]
top:[Token]
right:[Token]
bottom:[Token]
left:[[Token]]
_) <- forall a. [a] -> [a]
cycle [[Token]]
x =
                [(Text
"padding-top", [Token]
top), (Text
"padding-right", [Token]
right),
                 (Text
"padding-bottom", [Token]
bottom), (Text
"padding-left", [Token]
left)]
      where x :: [[Token]]
x = [Token] -> [[Token]]
parseOperands [Token]
toks
    shorthand CSSBox a
self Text
"border-width" [Token]
toks
        | forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Token]]
x forall a. Ord a => a -> a -> Bool
> Int
0 Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Token]]
x forall a. Ord a => a -> a -> Bool
<= Int
4, ([Token]
top:[Token]
right:[Token]
bottom:[Token]
left:[[Token]]
_) <- forall a. [a] -> [a]
cycle [[Token]]
x,
            forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (forall {a}. PropertyParser a => a -> Text -> [Token] -> Bool
validProp CSSBox a
self Text
"border-top-width") [[Token]]
x =
                [(Text
"border-top-width", [Token]
top), (Text
"border-right-width", [Token]
right),
                 (Text
"border-bottom-width", [Token]
bottom), (Text
"border-left-width", [Token]
left)]
      where x :: [[Token]]
x = [Token] -> [[Token]]
parseOperands [Token]
toks

    shorthand CSSBox a
self Text
k [Token]
v | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- forall a.
PropertyParser a =>
a -> Text -> [Token] -> [(Text, [Token])]
shorthand (forall a. CSSBox a -> Pattern
font CSSBox a
self) Text
k [Token]
v = [(Text, [Token])]
ret
    shorthand CSSBox a
self Text
k [Token]
v | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- forall a.
PropertyParser a =>
a -> Text -> [Token] -> [(Text, [Token])]
shorthand (forall a. CSSBox a -> CSSFont
font' CSSBox a
self) Text
k [Token]
v = [(Text, [Token])]
ret
    shorthand CSSBox a
self Text
k [Token]
v | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- forall a.
PropertyParser a =>
a -> Text -> [Token] -> [(Text, [Token])]
shorthand (forall a. CSSBox a -> CSSInline
inlineStyles CSSBox a
self) Text
k [Token]
v = [(Text, [Token])]
ret
    shorthand CSSBox a
self Text
k [Token]
v | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- forall a.
PropertyParser a =>
a -> Text -> [Token] -> [(Text, [Token])]
shorthand (forall a. CSSBox a -> CSSGrid
gridStyles CSSBox a
self) Text
k [Token]
v = [(Text, [Token])]
ret
    shorthand CSSBox a
self Text
k [Token]
v | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- forall a.
PropertyParser a =>
a -> Text -> [Token] -> [(Text, [Token])]
shorthand (forall a. CSSBox a -> CSSCell
cellStyles CSSBox a
self) Text
k [Token]
v = [(Text, [Token])]
ret
    shorthand CSSBox a
self Text
k [Token]
v | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- forall a.
PropertyParser a =>
a -> Text -> [Token] -> [(Text, [Token])]
shorthand (forall a. CSSBox a -> TableOptions
tableOptions CSSBox a
self) Text
k [Token]
v = [(Text, [Token])]
ret
    shorthand CSSBox a
self Text
k [Token]
v | ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_) <- forall a.
PropertyParser a =>
a -> Text -> [Token] -> [(Text, [Token])]
shorthand (forall a. CSSBox a -> a
inner CSSBox a
self) Text
k [Token]
v = [(Text, [Token])]
ret
    shorthand CSSBox a
self Text
k [Token]
v
        | ([Token]
v', [Token]
ls)<-[Token] -> ([Token], [Token])
testLengthProp [Token]
v, ret :: [(Text, [Token])]
ret@((Text, [Token])
_:[(Text, [Token])]
_)<-forall a.
PropertyParser a =>
a -> Text -> [Token] -> [(Text, [Token])]
shorthand (forall a. CSSBox a -> a
inner CSSBox a
self) Text
k [Token]
v' =
            [(Text
key, forall a b. (a -> b) -> [a] -> [b]
map ([Token] -> Token -> Token
restore [Token]
ls) [Token]
value) | (Text
key, [Token]
value) <- [(Text, [Token])]
ret]
      where
        restore :: [Token] -> Token -> Token
restore [Token]
ls (Dimension Text
_ (NVInteger Integer
x) Text
"px") | Int
x' forall a. Ord a => a -> a -> Bool
< forall (t :: * -> *) a. Foldable t => t a -> Int
length [Token]
ls = [Token]
ls forall a. [a] -> Int -> a
!! Int
x'
          where x' :: Int
x' = forall a. Num a => Integer -> a
fromInteger Integer
x
        restore [Token]
_ Token
ret = Token
ret
    shorthand CSSBox a
self Text
k [Token]
v | Just CSSBox a
_ <- forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand CSSBox a
self CSSBox a
self Text
k [Token]
v = [(Text
k, [Token]
v)]
        | Bool
otherwise = []

validProp :: a -> Text -> [Token] -> Bool
validProp a
self Text
key [Token]
value = forall a. Maybe a -> Bool
isJust forall a b. (a -> b) -> a -> b
$ forall a. PropertyParser a => a -> a -> Text -> [Token] -> Maybe a
longhand a
self a
self Text
key [Token]
value

testLengthProp :: [Token] -> ([Token], [Token])
testLengthProp (tok :: Token
tok@(Dimension Text
_ NumericValue
_ Text
unit):[Token]
toks) | Text
unit forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
units =
    let ([Token]
toks', [Token]
lengths) = [Token] -> ([Token], [Token])
testLengthProp [Token]
toks
    in (Text -> NumericValue -> Text -> Token
Dimension Text
"" (Integer -> NumericValue
NVInteger forall a b. (a -> b) -> a -> b
$ forall a. Integral a => a -> Integer
toInteger forall a b. (a -> b) -> a -> b
$ forall a. Enum a => a -> a
succ forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length [Token]
lengths) Text
"px"forall a. a -> [a] -> [a]
:[Token]
toks',
        Token
tokforall a. a -> [a] -> [a]
:[Token]
lengths)
testLengthProp (Token
tok:[Token]
toks) = let ([Token]
toks',[Token]
ls) = [Token] -> ([Token], [Token])
testLengthProp [Token]
toks in (Token
tokforall a. a -> [a] -> [a]
:[Token]
toks',[Token]
ls)
testLengthProp [] = ([], [])