css/cssvalues

Search:
Group by:

Types

CSSBorderCollapse = enum
  BorderCollapseSeparate = "separate", BorderCollapseCollapse = "collapse"
CSSBorderStyle = enum
  BorderStyleNone = "none", BorderStyleHidden = "hidden",
  BorderStyleDotted = "dotted", BorderStyleDashed = "dashed",
  BorderStyleSolid = "solid", BorderStyleDouble = "double",
  BorderStyleGroove = "groove", BorderStyleRidge = "ridge",
  BorderStyleInset = "inset", BorderStyleOutset = "outset",
  BorderStyleBracket = "-cha-bracket", BorderStyleParen = "-cha-paren",
  BorderStyleHash = "-cha-hash", BorderStylePeriod = "-cha-period"
CSSBoxSizing = enum
  BoxSizingContentBox = "content-box", BoxSizingBorderBox = "border-box"
CSSCaptionSide = enum
  CaptionSideTop = "top", CaptionSideBottom = "bottom",
  CaptionSideBlockStart = "block-start", CaptionSideBlockEnd = "block-end"
CSSClear = enum
  ClearNone = "none", ClearLeft = "left", ClearRight = "right",
  ClearBoth = "both", ClearInlineStart = "inline-start",
  ClearInlineEnd = "inline-end"
CSSComputedEntry = object
  p*: CSSWidePropertyType
  case et*: CSSEntryType
  of ceBit:
    bit*: uint8
  of ceHWord:
    hword*: CSSValueHWord
  of ceWord:
    word*: CSSValueWord
  of ceObject:
    obj*: CSSValue
  of ceVar:
    cvar*: CSSVarEntry
  of ceGlobal:
    global*: CSSGlobalType
CSSContent = object
  case t*: CSSContentType
  of ContentString:
    s*: RefString
  of ContentCounter:
    counter*: CAtom
    counterStyle*: CSSListStyleType
  else:
    nil
CSSContentType = enum
  ContentString = "-cha-string", ContentCounter = "-cha-counter",
  ContentOpenQuote = "open-quote", ContentCloseQuote = "close-quote",
  ContentNoOpenQuote = "no-open-quote", ContentNoCloseQuote = "no-close-quote"
CSSCounterSet = object
  name*: CAtom
  num*: int32
CSSDisplay = enum
  DisplayInline = "inline", DisplayNone = "none", DisplayBlock = "block",
  DisplayListItem = "list-item", DisplayInlineBlock = "inline-block",
  DisplayTable = "table", DisplayInlineTable = "inline-table",
  DisplayTableRowGroup = "table-row-group",
  DisplayTableHeaderGroup = "table-header-group",
  DisplayTableFooterGroup = "table-footer-group",
  DisplayTableColumnGroup = "table-column-group", DisplayTableRow = "table-row",
  DisplayTableColumn = "table-column", DisplayTableCell = "table-cell",
  DisplayTableCaption = "table-caption", DisplayFlowRoot = "flow-root",
  DisplayFlex = "flex", DisplayInlineFlex = "inline-flex", DisplayGrid = "grid",
  DisplayInlineGrid = "inline-grid", DisplayTableWrapper = "",
  DisplayMarker = "", DisplayImageBlock = "", DisplayImageInline = ""
CSSEntryType = enum
  ceBit, ceWord, ceHWord, ceObject, ceVar, ceGlobal
CSSFlexDirection = enum
  FlexDirectionRow = "row", FlexDirectionRowReverse = "row-reverse",
  FlexDirectionColumn = "column", FlexDirectionColumnReverse = "column-reverse"
CSSFlexWrap = enum
  FlexWrapNowrap = "nowrap", FlexWrapWrap = "wrap",
  FlexWrapWrapReverse = "wrap-reverse"
CSSFloat = enum
  FloatNone = "none", FloatLeft = "left", FloatRight = "right"
CSSFontStyle = enum
  FontStyleNormal = "normal", FontStyleItalic = "italic",
  FontStyleOblique = "oblique"
CSSGlobalType = enum
  cgtInitial = "initial", cgtInherit = "inherit", cgtRevert = "revert",
  cgtUnset = "unset"
CSSLength = object
  npx*: float32
  perc*: float32
CSSListStylePosition = enum
  ListStylePositionOutside = "outside", ListStylePositionInside = "inside"
CSSListStyleType = enum
  ListStyleTypeDisc = "disc", ListStyleTypeNone = "none",
  ListStyleTypeCircle = "circle", ListStyleTypeSquare = "square",
  ListStyleTypeDecimal = "decimal",
  ListStyleTypeDisclosureClosed = "disclosure-closed",
  ListStyleTypeDisclosureOpen = "disclosure-open",
  ListStyleTypeCjkEarthlyBranch = "cjk-earthly-branch",
  ListStyleTypeCjkHeavenlyStem = "cjk-heavenly-stem",
  ListStyleTypeLowerRoman = "lower-roman",
  ListStyleTypeUpperRoman = "upper-roman",
  ListStyleTypeLowerAlpha = "lower-alpha",
  ListStyleTypeUpperAlpha = "upper-alpha",
  ListStyleTypeLowerGreek = "lower-greek", ListStyleTypeHiragana = "hiragana",
  ListStyleTypeHiraganaIroha = "hiragana-iroha",
  ListStyleTypeKatakana = "katakana",
  ListStyleTypeKatakanaIroha = "katakana-iroha",
  ListStyleTypeJapaneseInformal = "japanese-informal",
  ListStyleTypeJapaneseFormal = "japanese-formal",
  ListStyleTypeHint = "-cha-hint"
CSSOrigin = enum
  coUserAgent, coUser, coAuthor
CSSOverflow = enum
  OverflowVisible = "visible", OverflowHidden = "hidden", OverflowClip = "clip",
  OverflowScroll = "scroll", OverflowAuto = "auto", OverflowOverlay = "overlay"
CSSPosition = enum
  PositionStatic = "static", PositionRelative = "relative",
  PositionAbsolute = "absolute", PositionFixed = "fixed",
  PositionSticky = "sticky"
CSSPropertyReprType = enum
  cprtBit, cprtHWord, cprtWord, cprtObject
CSSQuotes = ref object
  qs*: seq[tuple[s, e: RefString]]
CSSTextAlign = enum
  TextAlignStart = "start", TextAlignEnd = "end", TextAlignLeft = "left",
  TextAlignRight = "right", TextAlignCenter = "center",
  TextAlignJustify = "justify", TextAlignChaCenter = "-cha-center",
  TextAlignChaLeft = "-cha-left", TextAlignChaRight = "-cha-right"
CSSTextDecoration = enum
  TextDecorationNone = "none", TextDecorationUnderline = "underline",
  TextDecorationOverline = "overline",
  TextDecorationLineThrough = "line-through", TextDecorationBlink = "blink",
  TextDecorationReverse = "-cha-reverse"
CSSTextTransform = enum
  TextTransformNone = "none", TextTransformCapitalize = "capitalize",
  TextTransformUppercase = "uppercase", TextTransformLowercase = "lowercase",
  TextTransformFullWidth = "full-width",
  TextTransformFullSizeKana = "full-size-kana",
  TextTransformChaHalfWidth = "-cha-half-width"
CSSValue = ref object
  case v*: CSSValueType
  of cvtContent:
    content*: seq[CSSContent]
  of cvtQuotes:
    quotes*: CSSQuotes
  of cvtCounterSet:
    counterSet*: seq[CSSCounterSet]
  of cvtImage:
    image*: NetworkBitmap
  else:
    nil
CSSValueBit {.union.} = object
  dummy*: uint8
  bgcolorIsCanvas*: bool
  borderCollapse*: CSSBorderCollapse
  borderStyle*: CSSBorderStyle
  boxSizing*: CSSBoxSizing
  captionSide*: CSSCaptionSide
  clear*: CSSClear
  display*: CSSDisplay
  flexDirection*: CSSFlexDirection
  flexWrap*: CSSFlexWrap
  float*: CSSFloat
  fontStyle*: CSSFontStyle
  listStylePosition*: CSSListStylePosition
  listStyleType*: CSSListStyleType
  overflow*: CSSOverflow
  position*: CSSPosition
  textAlign*: CSSTextAlign
  textDecoration*: set[CSSTextDecoration]
  textTransform*: CSSTextTransform
  verticalAlign*: CSSVerticalAlign
  visibility*: CSSVisibility
  whiteSpace*: CSSWhiteSpace
  wordBreak*: CSSWordBreak
CSSValueHWord {.union.} = object
  integer*: int32
  number*: float32
  lineWidth*: float32
CSSValues = ref object
  pseudo*: PseudoElement
  invalid*: bool
  relayout*: bool
  bits*: array[CSSPropertyType.low .. LastBitPropType, CSSValueBit]
  hwords*: array[FirstHWordPropType .. LastHWordPropType, CSSValueHWord]
  words*: array[FirstWordPropType .. LastWordPropType, CSSValueWord]
  objs*: array[FirstObjPropType .. CSSPropertyType.high, CSSValue]
  vars*: CSSVariableMap
  next*: CSSValues
CSSValueType = enum
  cvtBgcolorIsCanvas = "bgcolorIsCanvas", cvtBorderCollapse = "borderCollapse",
  cvtBorderStyle = "borderStyle", cvtBoxSizing = "boxSizing",
  cvtCaptionSide = "captionSide", cvtClear = "clear", cvtColor = "color",
  cvtContent = "content", cvtCounterSet = "counterSet", cvtDisplay = "display",
  cvtFlexDirection = "flexDirection", cvtFlexWrap = "flexWrap",
  cvtFloat = "float", cvtFontStyle = "fontStyle", cvtImage = "image",
  cvtInteger = "integer", cvtLength = "length", cvtLineWidth = "lineWidth",
  cvtListStylePosition = "listStylePosition",
  cvtListStyleType = "listStyleType", cvtNumber = "number",
  cvtOverflow = "overflow", cvtPosition = "position", cvtQuotes = "quotes",
  cvtTextAlign = "textAlign", cvtTextDecoration = "textDecoration",
  cvtTextTransform = "textTransform", cvtVerticalAlign = "verticalAlign",
  cvtVisibility = "visibility", cvtWhiteSpace = "whiteSpace",
  cvtWordBreak = "wordBreak", cvtZIndex = "zIndex"
CSSValueWord {.union.} = object
  dummy*: uint64
  color*: CSSColor
  length*: CSSLength
  zIndex*: CSSZIndex
CSSVarEntry = ref object
  resolved*: seq[tuple[vars: CSSVariableMap, entries: seq[CSSComputedEntry]]]
  items*: seq[CSSVarItem]
CSSVariable = ref object
  name*: CAtom
  items*: seq[CSSVarItem]
CSSVariableMap = ref object
  parent*: CSSVariableMap
  table*: Table[CAtom, CSSVariable]
CSSVarItem = object
  name*: CAtom
  toks*: seq[CSSToken]
CSSVerticalAlign = enum
  VerticalAlignBaseline = "baseline", VerticalAlignSub = "sub",
  VerticalAlignSuper = "super", VerticalAlignTextTop = "text-top",
  VerticalAlignTextBottom = "text-bottom", VerticalAlignMiddle = "middle",
  VerticalAlignTop = "top", VerticalAlignBottom = "bottom",
  VerticalAlignLength = "-cha-length"
CSSVisibility = enum
  VisibilityVisible = "visible", VisibilityHidden = "hidden",
  VisibilityCollapse = "collapse"
CSSWhiteSpace = enum
  WhiteSpaceNormal = "normal", WhiteSpaceNowrap = "nowrap",
  WhiteSpacePre = "pre", WhiteSpacePreLine = "pre-line",
  WhiteSpacePreWrap = "pre-wrap"
CSSWordBreak = enum
  WordBreakNormal = "normal", WordBreakBreakAll = "break-all",
  WordBreakKeepAll = "keep-all"
CSSZIndex = object
  num*: int32

Consts

BorderStyleInput = {BorderStyleBracket, BorderStyleParen, BorderStyleHash}
BorderStyleNoneHidden = {BorderStyleNone, BorderStyleHidden}
CSSLengthAuto = (npx: nan, perc: nan)
CSSLengthZero = (npx: 0.0, perc: 0.0)
DisplayInlineBlockLike = {DisplayInlineTable, DisplayInlineBlock,
                          DisplayInlineFlex, DisplayInlineGrid, DisplayMarker,
                          DisplayImageInline}
DisplayInnerBlock = {DisplayBlock, DisplayFlowRoot, DisplayTableCaption,
                     DisplayTableCell, DisplayInlineBlock, DisplayListItem,
                     DisplayMarker}
DisplayInnerFlex = {DisplayFlex, DisplayInlineFlex}
DisplayInnerGrid = {DisplayGrid, DisplayInlineGrid}
DisplayInnerTable = {DisplayTable, DisplayInlineTable}
DisplayInternalTable = {DisplayTableRowGroup..DisplayTableCaption}
DisplayNeverHasStack = {DisplayTableRowGroup..DisplayTableColumn,
                        DisplayTableCaption}
DisplayOuterBlock = {DisplayFlex, DisplayGrid, DisplayBlock, DisplayImageBlock,
                     DisplayTable, DisplayFlowRoot, DisplayTableWrapper,
                     DisplayListItem}
DisplayOuterInline = {DisplayInline, DisplayInlineBlock, DisplayInlineTable,
                      DisplayInlineFlex, DisplayInlineGrid, DisplayMarker,
                      DisplayImageInline}
FlexReverse = {FlexDirectionRowReverse, FlexDirectionColumnReverse}
LayoutProperties = {cptMarginLeft, cptMarginRight, cptMarginTop,
                    cptMarginBottom, cptPaddingLeft, cptPaddingRight,
                    cptPaddingTop, cptPaddingBottom, cptBoxSizing,
                    cptBorderLeftStyle, cptBorderRightStyle, cptBorderTopStyle,
                    cptBorderBottomStyle, cptBorderLeftWidth,
                    cptBorderRightWidth, cptBorderTopWidth,
                    cptBorderBottomWidth, cptLeft, cptRight, cptTop, cptBottom,
                    cptWidth, cptHeight, cptFlexShrink, cptFlexGrow,
                    cptFlexBasis, cptOverflowX, cptOverflowY, cptWhiteSpace,
                    cptVerticalAlign, cptTextAlign, cptVerticalAlignLength,
                    cptWordBreak, cptTextTransform, cptFloat, cptClear,
                    cptMinWidth, cptMinHeight, cptMaxWidth, cptMaxHeight,
                    cptChaColspan, cptChaRowspan, cptVisibility,
                    cptBorderCollapse, cptBorderSpacingInline,
                    cptBorderSpacingBlock, cptCaptionSide, cptPosition}
OverflowHiddenLike = {OverflowHidden, OverflowClip}
OverflowScrollLike = {OverflowScroll, OverflowAuto, OverflowOverlay}
PositionAbsoluteFixed = {PositionAbsolute, PositionFixed}
RowGroupBox = {DisplayTableRowGroup, DisplayTableHeaderGroup,
               DisplayTableFooterGroup}
WhiteSpacePreserve = {WhiteSpacePre, WhiteSpacePreLine, WhiteSpacePreWrap}

Procs

proc `$`(bmp: NetworkBitmap): string {....raises: [], tags: [], forbids: [].}
proc `$`(computed: CSSValues): string {....raises: [], tags: [], forbids: [].}
proc `$`(content: CSSContent): string {....raises: [], tags: [], forbids: [].}
proc `$`(length: CSSLength): string {....raises: [], tags: [], forbids: [].}
proc bfcify(overflow: CSSOverflow): CSSOverflow {....raises: [], tags: [],
    forbids: [].}
proc blockify(display: CSSDisplay): CSSDisplay {....raises: [], tags: [],
    forbids: [].}
proc borderChar(style: CSSBorderStyle; c: BoxDrawingChar): string {....raises: [],
    tags: [], forbids: [].}
proc copyFrom(a, b: CSSValues; t: CSSPropertyType) {....raises: [], tags: [],
    forbids: [].}
proc copyProperties(props: CSSValues): CSSValues {....raises: [], tags: [],
    forbids: [].}
proc equals(a, b: CSSValues; t: CSSPropertyType): bool {....raises: [], tags: [],
    forbids: [].}
proc getBorderStyle(vals: CSSValues; p: CSSPropertyType): CSSBorderStyle {.
    ...raises: [], tags: [], forbids: [].}
proc getLength(vals: CSSValues; p: CSSPropertyType): CSSLength {....raises: [],
    tags: [], forbids: [].}
proc getLineWidth(vals: CSSValues; p: CSSPropertyType): float32 {....raises: [],
    tags: [], forbids: [].}
proc imgify(display: CSSDisplay): CSSDisplay {....raises: [], tags: [], forbids: [].}
proc inherited(t: CSSPropertyType): bool {....raises: [], tags: [], forbids: [].}
proc inheritProperties(parent: CSSValues): CSSValues {....raises: [], tags: [],
    forbids: [].}
proc initialOrCopyFrom(a, b: CSSValues; t: CSSPropertyType) {....raises: [],
    tags: [], forbids: [].}
proc initialOrInheritFrom(a, b: CSSValues; t: CSSPropertyType) {....raises: [],
    tags: [], forbids: [].}
proc isPerc(length: CSSLength): bool {.inline, ...raises: [], tags: [], forbids: [].}
proc isSupportedProperty(s: string): bool {....raises: [], tags: [], forbids: [].}
proc isZero(length: CSSLength): bool {.inline, ...raises: [], tags: [], forbids: [].}
proc listMarker(t: CSSListStyleType; i: int32; suffix: bool;
                hintMap: openArray[uint32]): RefString {....raises: [], tags: [],
    forbids: [].}
proc makeEntry(t: CSSPropertyType; bit: CSSValueBit): CSSComputedEntry {.
    ...raises: [], tags: [], forbids: [].}
proc makeEntry(t: CSSPropertyType; color: CSSColor): CSSComputedEntry {.
    ...raises: [], tags: [], forbids: [].}
proc makeEntry(t: CSSPropertyType; integer: int32): CSSComputedEntry {.
    ...raises: [], tags: [], forbids: [].}
proc makeEntry(t: CSSPropertyType; length: CSSLength): CSSComputedEntry {.
    ...raises: [], tags: [], forbids: [].}
proc makeEntry(t: CSSPropertyType; number: float32): CSSComputedEntry {.
    ...raises: [], tags: [], forbids: [].}
proc makeEntry(t: CSSPropertyType; obj: CSSValue): CSSComputedEntry {.
    ...raises: [], tags: [], forbids: [].}
proc newCSSVariableMap(parent: CSSVariableMap): CSSVariableMap {....raises: [],
    tags: [], forbids: [].}
proc parseColor(ctx: var CSSParser): Opt[CSSColor] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc parseComputedValues(res: var seq[CSSComputedEntry]; p: CSSWidePropertyType;
                         toks: openArray[CSSToken]; attrs: WindowAttributes) {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc parseComputedValues0(ctx: var CSSParser; p: CSSWidePropertyType;
                          attrs: WindowAttributes;
                          res: var seq[CSSComputedEntry]): Opt[void] {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc parseDeclWithVar(p: CSSWidePropertyType; value: openArray[CSSToken]): Opt[
    CSSComputedEntry] {....raises: [], tags: [], forbids: [].}
proc parseDeclWithVar0(toks: openArray[CSSToken]): seq[CSSVarItem] {....raises: [],
    tags: [], forbids: [].}
proc parseLength(ctx: var CSSParser; attrs: WindowAttributes; hasAuto = true;
                 allowNegative = true): Opt[CSSLength] {....raises: [],
    tags: [RootEffect], forbids: [].}
proc parseLength(toks: openArray[CSSToken]; attrs: WindowAttributes;
                 hasAuto = true; allowNegative = true): Opt[CSSLength] {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc parseURL(ctx: var CSSParser; tok: CSSToken; src = false): Opt[string] {.
    ...raises: [], tags: [RootEffect], forbids: [].}
proc putIfAbsent(map: CSSVariableMap; name: CAtom; cvar: CSSVariable) {.
    ...raises: [], tags: [], forbids: [].}
proc quoteEnd(level: int): string {....raises: [], tags: [], forbids: [].}
proc quoteStart(level: int): string {....raises: [], tags: [], forbids: [].}
proc reprType(t: CSSPropertyType): CSSPropertyReprType {....raises: [], tags: [],
    forbids: [].}
proc resolveLength(u: CSSUnit; val: float32; attrs: WindowAttributes): CSSLength {.
    ...raises: [], tags: [], forbids: [].}
proc rootProperties(): CSSValues {....raises: [], tags: [], forbids: [].}
proc serialize(computed: CSSValues; p: CSSPropertyType): string {....raises: [],
    tags: [], forbids: [].}
proc setAllInitial(a: CSSValues) {....raises: [], tags: [], forbids: [].}
proc setInitial(a: CSSValues; t: CSSPropertyType) {....raises: [], tags: [],
    forbids: [].}
proc splitTable(computed: CSSValues): tuple[outer, innner: CSSValues] {.
    ...raises: [], tags: [], forbids: [].}
proc valueType(prop: CSSPropertyType): CSSValueType {....raises: [], tags: [],
    forbids: [].}

Macros

macro `{}`(vals: CSSValues; s: static string): untyped {..}
macro `{}=`(vals: CSSValues; s: static string; val: typed) {..}

Templates

template auto(length: CSSLength): bool {..}
template cssLength(n: float32): CSSLength {..}
template cssLengthFrac(n: float32): CSSLength {..}
template cssLengthPerc(n: float32): CSSLength {..}
template isPx(length: CSSLength): bool {..}
template makeEntry[T: enum | set](t: CSSPropertyType; val: T): CSSComputedEntry {..}

Made with Nim. Generated: 2026-05-20 06:09:08 UTC