about summary refs log tree commit diff stats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/css/cascade.nim4
-rw-r--r--src/css/cssparser.nim110
-rw-r--r--src/css/cssvalues.nim94
-rw-r--r--src/css/mediaquery.nim29
-rw-r--r--src/css/selectorparser.nim28
5 files changed, 128 insertions, 137 deletions
diff --git a/src/css/cascade.nim b/src/css/cascade.nim
index a16cc15b..a946c8e7 100644
--- a/src/css/cascade.nim
+++ b/src/css/cascade.nim
@@ -64,9 +64,9 @@ func applies(mq: MediaQuery; window: Window): bool =
   of mctNot:
     return not mq.n.applies(window)
   of mctAnd:
-    return mq.anda.applies(window) and mq.andb.applies(window)
+    return mq.left.applies(window) and mq.right.applies(window)
   of mctOr:
-    return mq.ora.applies(window) or mq.orb.applies(window)
+    return mq.left.applies(window) or mq.right.applies(window)
   of mctFeature:
     return mq.feature.applies(window)
 
diff --git a/src/css/cssparser.nim b/src/css/cssparser.nim
index 0dc4f384..617a2a30 100644
--- a/src/css/cssparser.nim
+++ b/src/css/cssparser.nim
@@ -30,9 +30,8 @@ type
   CSSComponentValue* = ref object of CSSParsedItem
 
   CSSToken* = ref object of CSSComponentValue
-    case tokenType*: CSSTokenType
-    of cttIdent, cttFunction, cttAtKeyword,
-       cttHash, cttString, cttUrl:
+    case t*: CSSTokenType
+    of cttIdent, cttFunction, cttAtKeyword, cttHash, cttString, cttUrl:
       value*: string
       tflaga*: tflaga
     of cttDelim:
@@ -74,9 +73,9 @@ type
 proc `$`*(c: CSSParsedItem): string =
   if c of CSSToken:
     let c = CSSToken(c)
-    case c.tokenType:
+    case c.t:
     of cttFunction, cttAtKeyword:
-      result &= $c.tokenType & c.value & '\n'
+      result &= $c.t & c.value & '\n'
     of cttUrl:
       result &= "url(" & c.value & ")"
     of cttHash:
@@ -109,7 +108,7 @@ proc `$`*(c: CSSParsedItem): string =
     of cttComma:
       result &= ","
     else:
-      result &= $c.tokenType & '\n'
+      result &= $c.t & '\n'
   elif c of CSSDeclaration:
     let decl = CSSDeclaration(c)
     result &= decl.name
@@ -125,14 +124,14 @@ proc `$`*(c: CSSParsedItem): string =
       result &= $s
     result &= ")"
   elif c of CSSSimpleBlock:
-    case CSSSimpleBlock(c).token.tokenType
+    case CSSSimpleBlock(c).token.t
     of cttLbrace: result &= "{\n"
     of cttLparen: result &= "("
     of cttLbracket: result &= "["
     else: discard
     for s in CSSSimpleBlock(c).value:
       result &= $s
-    case CSSSimpleBlock(c).token.tokenType
+    case CSSSimpleBlock(c).token.t
     of cttLbrace: result &= "\n}"
     of cttLparen: result &= ")"
     of cttLbracket: result &= "]"
@@ -144,7 +143,7 @@ proc `$`*(c: CSSParsedItem): string =
     result &= $CSSRule(c).oblock
 
 func `==`*(a: CSSParsedItem, b: CSSTokenType): bool =
-  return a of CSSToken and CSSToken(a).tokenType == b
+  return a of CSSToken and CSSToken(a).t == b
 
 const IdentStart = AsciiAlpha + NonAscii + {'_'}
 const Ident = IdentStart + AsciiDigit + {'-'}
@@ -258,7 +257,7 @@ proc consumeString(state: var CSSTokenizerState): CSSToken =
     case c
     of '\n':
       state.reconsume()
-      return CSSToken(tokenType: cttBadString)
+      return CSSToken(t: cttBadString)
     of '\\':
       if not state.has():
         continue
@@ -270,7 +269,7 @@ proc consumeString(state: var CSSTokenizerState): CSSToken =
       break
     else:
       s &= c
-  return CSSToken(tokenType: cttString, value: s)
+  return CSSToken(t: cttString, value: s)
 
 proc consumeIdentSequence(state: var CSSTokenizerState): string =
   var s = ""
@@ -317,13 +316,13 @@ proc consumeNumber(state: var CSSTokenizerState): (tflagb, float64) =
 proc consumeNumericToken(state: var CSSTokenizerState): CSSToken =
   let (t, val) = state.consumeNumber()
   if state.next3startsWithIdentSequence():
-    result = CSSToken(tokenType: cttDimension, nvalue: val, tflagb: t)
+    result = CSSToken(t: cttDimension, nvalue: val, tflagb: t)
     result.unit = state.consumeIdentSequence()
   elif state.has() and state.peek() == '%':
     discard state.consume()
-    result = CSSToken(tokenType: cttPercentage, nvalue: val)
+    result = CSSToken(t: cttPercentage, nvalue: val)
   else:
-    result = CSSToken(tokenType: cttNumber, nvalue: val, tflagb: t)
+    result = CSSToken(t: cttNumber, nvalue: val, tflagb: t)
 
 proc consumeBadURL(state: var CSSTokenizerState) =
   while state.has():
@@ -341,7 +340,7 @@ const NonPrintable = {
 }
 
 proc consumeURL(state: var CSSTokenizerState): CSSToken =
-  result = CSSToken(tokenType: cttUrl)
+  result = CSSToken(t: cttUrl)
   state.skipWhitespace()
   while state.has():
     let c = state.consume()
@@ -350,7 +349,7 @@ proc consumeURL(state: var CSSTokenizerState): CSSToken =
       return result
     of '"', '\'', '(', NonPrintable:
       state.consumeBadURL()
-      return CSSToken(tokenType: cttBadUrl)
+      return CSSToken(t: cttBadUrl)
     of AsciiWhitespace:
       state.skipWhitespace()
       if not state.has():
@@ -359,14 +358,14 @@ proc consumeURL(state: var CSSTokenizerState): CSSToken =
         discard state.consume()
         return result
       state.consumeBadURL()
-      return CSSToken(tokenType: cttBadUrl)
+      return CSSToken(t: cttBadUrl)
     of '\\':
       state.reconsume()
       if state.isValidEscape():
         result.value &= state.consumeEscape()
       else:
         state.consumeBadURL()
-        return CSSToken(tokenType: cttBadUrl)
+        return CSSToken(t: cttBadUrl)
     else:
       result.value &= c
 
@@ -380,14 +379,14 @@ proc consumeIdentLikeToken(state: var CSSTokenizerState): CSSToken =
     if state.has() and state.peek() in {'"', '\''} or
         state.has(1) and state.peek() in {'"', '\''} + AsciiWhitespace and
         state.peek(1) in {'"', '\''}:
-      return CSSToken(tokenType: cttFunction, value: s)
+      return CSSToken(t: cttFunction, value: s)
     else:
       return state.consumeURL()
   elif state.has() and state.peek() == '(':
     discard state.consume()
-    return CSSToken(tokenType: cttFunction, value: s)
+    return CSSToken(t: cttFunction, value: s)
 
-  return CSSToken(tokenType: cttIdent, value: s)
+  return CSSToken(t: cttIdent, value: s)
 
 proc consumeComments(state: var CSSTokenizerState) =
   if state.has(1) and state.peek() == '/' and state.peek(1) == '*':
@@ -409,29 +408,29 @@ proc consumeToken(state: var CSSTokenizerState): CSSToken =
   case c
   of AsciiWhitespace:
     state.skipWhitespace()
-    return CSSToken(tokenType: cttWhitespace)
+    return CSSToken(t: cttWhitespace)
   of '"', '\'':
     return consumeString(state)
   of '#':
     if state.has() and state.peek() in Ident or state.isValidEscape():
-      result = CSSToken(tokenType: cttHash)
+      result = CSSToken(t: cttHash)
       if state.startsWithIdentSequence():
         result.tflaga = tflagaId
       result.value = consumeIdentSequence(state)
     else:
       state.reconsume()
-      return CSSToken(tokenType: cttDelim, cvalue: state.consumeRChar())
-  of '(': return CSSToken(tokenType: cttLparen)
-  of ')': return CSSToken(tokenType: cttRparen)
-  of '{': return CSSToken(tokenType: cttLbrace)
-  of '}': return CSSToken(tokenType: cttRbrace)
+      return CSSToken(t: cttDelim, cvalue: state.consumeRChar())
+  of '(': return CSSToken(t: cttLparen)
+  of ')': return CSSToken(t: cttRparen)
+  of '{': return CSSToken(t: cttLbrace)
+  of '}': return CSSToken(t: cttRbrace)
   of '+':
     if state.startsWithNumber():
       state.reconsume()
       return state.consumeNumericToken()
     else:
-      return CSSToken(tokenType: cttDelim, cvalue: c)
-  of ',': return CSSToken(tokenType: cttComma)
+      return CSSToken(t: cttDelim, cvalue: c)
+  of ',': return CSSToken(t: cttComma)
   of '-':
     if state.startsWithNumber():
       state.reconsume()
@@ -440,43 +439,43 @@ proc consumeToken(state: var CSSTokenizerState): CSSToken =
       if state.has(1) and state.peek() == '-' and state.peek(1) == '>':
         discard state.consume()
         discard state.consume()
-        return CSSToken(tokenType: cttCdc)
+        return CSSToken(t: cttCdc)
       elif state.startsWithIdentSequence():
         state.reconsume()
         return state.consumeIdentLikeToken()
       else:
-        return CSSToken(tokenType: cttDelim, cvalue: c)
+        return CSSToken(t: cttDelim, cvalue: c)
   of '.':
     if state.startsWithNumber():
       state.reconsume()
       return state.consumeNumericToken()
     else:
-      return CSSToken(tokenType: cttDelim, cvalue: c)
-  of ':': return CSSToken(tokenType: cttColon)
-  of ';': return CSSToken(tokenType: cttSemicolon)
+      return CSSToken(t: cttDelim, cvalue: c)
+  of ':': return CSSToken(t: cttColon)
+  of ';': return CSSToken(t: cttSemicolon)
   of '<':
     if state.has(2) and state.peek() == '!' and state.peek(1) == '-' and
         state.peek(2) == '-':
       discard state.consume()
       discard state.consume()
       discard state.consume()
-      return CSSToken(tokenType: cttCdo)
+      return CSSToken(t: cttCdo)
     else:
-      return CSSToken(tokenType: cttDelim, cvalue: c)
+      return CSSToken(t: cttDelim, cvalue: c)
   of '@':
     if state.next3startsWithIdentSequence():
       let name = state.consumeIdentSequence()
-      return CSSToken(tokenType: cttAtKeyword, value: name)
+      return CSSToken(t: cttAtKeyword, value: name)
     else:
-      return CSSToken(tokenType: cttDelim, cvalue: c)
-  of '[': return CSSToken(tokenType: cttLbracket)
+      return CSSToken(t: cttDelim, cvalue: c)
+  of '[': return CSSToken(t: cttLbracket)
   of '\\':
     if state.isValidEscape():
       state.reconsume()
       return state.consumeIdentLikeToken()
     else:
-      return CSSToken(tokenType: cttDelim, cvalue: c)
-  of ']': return CSSToken(tokenType: cttRbracket)
+      return CSSToken(t: cttDelim, cvalue: c)
+  of ']': return CSSToken(t: cttRbracket)
   of AsciiDigit:
     state.reconsume()
     return state.consumeNumericToken()
@@ -485,7 +484,7 @@ proc consumeToken(state: var CSSTokenizerState): CSSToken =
     return state.consumeIdentLikeToken()
   else:
     state.reconsume()
-    return CSSToken(tokenType: cttDelim, cvalue: state.consumeRChar())
+    return CSSToken(t: cttDelim, cvalue: state.consumeRChar())
 
 proc tokenizeCSS*(ibuf: string): seq[CSSParsedItem] =
   var state = CSSTokenizerState(buf: ibuf)
@@ -513,20 +512,21 @@ proc skipWhitespace(state: var CSSParseState) =
 
 proc consumeComponentValue(state: var CSSParseState): CSSComponentValue
 
-proc consumeSimpleBlock(state: var CSSParseState; t: CSSToken): CSSSimpleBlock =
+proc consumeSimpleBlock(state: var CSSParseState; tok: CSSToken):
+    CSSSimpleBlock =
   var ending: CSSTokenType
-  case t.tokenType
+  case tok.t
   of cttLbrace: ending = cttRbrace
   of cttLparen: ending = cttRparen
   of cttLbracket: ending = cttRbracket
   else: doAssert false
-  result = CSSSimpleBlock(token: t)
+  result = CSSSimpleBlock(token: tok)
   while state.at < state.tokens.len:
-    let t = state.consume()
-    if t == ending:
+    let tok = state.consume()
+    if tok == ending:
       break
-    elif t == cttLbrace or t == cttLbracket or t == cttLparen:
-      result.value.add(state.consumeSimpleBlock(CSSToken(t)))
+    elif tok == cttLbrace or tok == cttLbracket or tok == cttLparen:
+      result.value.add(state.consumeSimpleBlock(CSSToken(tok)))
     else:
       state.reconsume()
       result.value.add(state.consumeComponentValue())
@@ -835,7 +835,7 @@ proc parseAnB*(state: var CSSParseState): Option[CSSAnB] =
       return none(CSSAnB)
     x.get
   template fail_non_integer(tok: CSSToken; res: Option[CSSAnB]) =
-    if tok.tokenType != cttNumber:
+    if tok.t != cttNumber:
       state.reconsume()
       return res
     if tok.tflagb != tflagbInteger:
@@ -852,7 +852,7 @@ proc parseAnB*(state: var CSSParseState): Option[CSSAnB] =
   fail_eof
   let is_plus = get_plus
   let tok = get_tok_nows
-  case tok.tokenType
+  case tok.t
   of cttIdent:
     case tok.value
     of "odd":
@@ -866,7 +866,7 @@ proc parseAnB*(state: var CSSParseState): Option[CSSAnB] =
       if is_eof:
         return some((1, 0))
       let tok2 = get_tok_nows
-      if tok2.tokenType == cttDelim:
+      if tok2.t == cttDelim:
         let sign = case tok2.cvalue
         of '+': 1
         of '-': -1
@@ -883,7 +883,7 @@ proc parseAnB*(state: var CSSParseState): Option[CSSAnB] =
       if is_eof:
         return some((-1, 0))
       let tok2 = get_tok_nows
-      if tok2.tokenType == cttDelim:
+      if tok2.t == cttDelim:
         let sign = case tok2.cvalue
         of '+': 1
         of '-': -1
@@ -931,7 +931,7 @@ proc parseAnB*(state: var CSSParseState): Option[CSSAnB] =
       if is_eof:
         return some((int(tok.nvalue), 0))
       let tok2 = get_tok_nows
-      if tok2.tokenType == cttDelim:
+      if tok2.t == cttDelim:
         let sign = case tok2.cvalue
         of '+': 1
         of '-': -1
diff --git a/src/css/cssvalues.nim b/src/css/cssvalues.nim
index 22176433..d9771917 100644
--- a/src/css/cssvalues.nim
+++ b/src/css/cssvalues.nim
@@ -777,16 +777,10 @@ func quoteEnd*(level: int): string =
     return "“"
   return "‘"
 
-template isToken(cval: CSSComponentValue): bool =
-  cval of CSSToken
-
-template getToken(cval: CSSComponentValue): CSSToken =
-  CSSToken(cval)
-
 func parseIdent(map: openArray[IdentMapItem]; cval: CSSComponentValue): int =
-  if isToken(cval):
-    let tok = getToken(cval)
-    if tok.tokenType == cttIdent:
+  if cval of CSSToken:
+    let tok = CSSToken(cval)
+    if tok.t == cttIdent:
       return map.parseEnumNoCase0(tok.value)
   return -1
 
@@ -886,11 +880,11 @@ func parseANSI(value: openArray[CSSComponentValue]): Opt[CSSColor] =
     #TODO numeric functions
     return err()
   let tok = CSSToken(value[i])
-  if tok.tokenType == cttNumber:
+  if tok.t == cttNumber:
     if tok.tflagb != tflagbInteger or int(tok.nvalue) notin 0..255:
       return err() # invalid numeric ANSI color
     return ok(ANSIColor(tok.nvalue).cssColor())
-  elif tok.tokenType == cttIdent:
+  elif tok.t == cttIdent:
     var name = tok.value
     if name.equalsIgnoreCase("default"):
       return ok(defaultColor.cssColor())
@@ -919,7 +913,7 @@ func parseANSI(value: openArray[CSSComponentValue]): Opt[CSSColor] =
 func cssColor*(val: CSSComponentValue): Opt[CSSColor] =
   if val of CSSToken:
     let tok = CSSToken(val)
-    case tok.tokenType
+    case tok.t
     of cttHash:
       let c = parseHexColor(tok.value)
       if c.isSome:
@@ -943,7 +937,7 @@ func cssLength*(val: CSSComponentValue; has_auto = true; allow_negative = true):
     Opt[CSSLength] =
   if val of CSSToken:
     let tok = CSSToken(val)
-    case tok.tokenType
+    case tok.t
     of cttNumber:
       if tok.nvalue == 0:
         return ok(CSSLength(num: 0, u: cuPx))
@@ -967,7 +961,7 @@ func cssLength*(val: CSSComponentValue; has_auto = true; allow_negative = true):
 func cssAbsoluteLength(val: CSSComponentValue): Opt[CSSLength] =
   if val of CSSToken:
     let tok = CSSToken(val)
-    case tok.tokenType
+    case tok.t
     of cttNumber:
       if tok.nvalue == 0:
         return ok(CSSLength(num: 0, u: cuPx))
@@ -990,9 +984,9 @@ func cssQuotes(cvals: openArray[CSSComponentValue]): Opt[CSSQuotes] =
   var pair: tuple[s, e: string]
   for cval in cvals:
     if res.auto: die
-    if isToken(cval):
-      let tok = getToken(cval)
-      case tok.tokenType
+    if cval of CSSToken:
+      let tok = CSSToken(cval)
+      case tok.t
       of cttIdent:
         if res.qs.len > 0: die
         if tok.value.equalsIgnoreCase("auto"):
@@ -1017,9 +1011,9 @@ func cssQuotes(cvals: openArray[CSSComponentValue]): Opt[CSSQuotes] =
 
 func cssContent(cvals: openArray[CSSComponentValue]): seq[CSSContent] =
   for cval in cvals:
-    if isToken(cval):
-      let tok = getToken(cval)
-      case tok.tokenType
+    if cval of CSSToken:
+      let tok = CSSToken(cval)
+      case tok.t
       of cttIdent:
         if tok.value == "/":
           break
@@ -1036,9 +1030,9 @@ func cssContent(cvals: openArray[CSSComponentValue]): seq[CSSContent] =
       else: return
 
 func cssFontWeight(cval: CSSComponentValue): Opt[int] =
-  if isToken(cval):
-    let tok = getToken(cval)
-    if tok.tokenType == cttIdent:
+  if cval of CSSToken:
+    let tok = CSSToken(cval)
+    if tok.t == cttIdent:
       const FontWeightMap = {
         "normal": 400,
         "bold": 700,
@@ -1048,7 +1042,7 @@ func cssFontWeight(cval: CSSComponentValue): Opt[int] =
       let i = FontWeightMap.parseIdent(cval)
       if i != -1:
         return ok(i)
-    elif tok.tokenType == cttNumber:
+    elif tok.t == cttNumber:
       if tok.nvalue in 1f64..1000f64:
         return ok(int(tok.nvalue))
   return err()
@@ -1057,10 +1051,10 @@ func cssTextDecoration(cvals: openArray[CSSComponentValue]):
     Opt[set[CSSTextDecoration]] =
   var s: set[CSSTextDecoration] = {}
   for cval in cvals:
-    if not isToken(cval):
+    if not (cval of CSSToken):
       continue
-    let tok = getToken(cval)
-    if tok.tokenType == cttIdent:
+    let tok = CSSToken(cval)
+    if tok.t == cttIdent:
       let td = ?parseIdent[CSSTextDecoration](tok)
       if td == TextDecorationNone:
         if cvals.len != 1:
@@ -1070,9 +1064,9 @@ func cssTextDecoration(cvals: openArray[CSSComponentValue]):
   return ok(s)
 
 func cssVerticalAlign(cval: CSSComponentValue): Opt[CSSVerticalAlign] =
-  if isToken(cval):
-    let tok = getToken(cval)
-    if tok.tokenType == cttIdent:
+  if cval of CSSToken:
+    let tok = CSSToken(cval)
+    if tok.t == cttIdent:
       let va2 = ?parseIdent[CSSVerticalAlign2](cval)
       return ok(CSSVerticalAlign(keyword: va2))
     else:
@@ -1092,9 +1086,9 @@ func cssCounterReset(cvals: openArray[CSSComponentValue]):
   var s = false
   var res: seq[CSSCounterReset] = @[]
   for cval in cvals:
-    if isToken(cval):
-      let tok = getToken(cval)
-      case tok.tokenType
+    if cval of CSSToken:
+      let tok = CSSToken(cval)
+      case tok.t
       of cttWhitespace: discard
       of cttIdent:
         if s:
@@ -1112,9 +1106,9 @@ func cssCounterReset(cvals: openArray[CSSComponentValue]):
   return ok(res)
 
 func cssMaxMinSize(cval: CSSComponentValue): Opt[CSSLength] =
-  if isToken(cval):
-    let tok = getToken(cval)
-    case tok.tokenType
+  if cval of CSSToken:
+    let tok = CSSToken(cval)
+    case tok.t
     of cttIdent:
       if tok.value.equalsIgnoreCase("none"):
         return ok(CSSLengthAuto)
@@ -1125,8 +1119,8 @@ func cssMaxMinSize(cval: CSSComponentValue): Opt[CSSLength] =
 
 #TODO should be URL (parsed with baseurl of document...)
 func cssURL*(cval: CSSComponentValue; src = false): Option[string] =
-  if isToken(cval):
-    let tok = getToken(cval)
+  if cval of CSSToken:
+    let tok = CSSToken(cval)
     if tok == cttUrl:
       return some(tok.value)
     elif not src and tok == cttString:
@@ -1136,9 +1130,9 @@ func cssURL*(cval: CSSComponentValue; src = false): Option[string] =
     if fun.name.equalsIgnoreCase("url") or
         src and fun.name.equalsIgnoreCase("src"):
       for x in fun.value:
-        if not isToken(x):
+        if not (x of CSSToken):
           break
-        let x = getToken(x)
+        let x = CSSToken(x)
         if x == cttWhitespace:
           discard
         elif x == cttString:
@@ -1149,10 +1143,10 @@ func cssURL*(cval: CSSComponentValue; src = false): Option[string] =
 
 #TODO this should be bg-image, add gradient, etc etc
 func cssImage(cval: CSSComponentValue): Opt[CSSContent] =
-  if isToken(cval):
+  if cval of CSSToken:
     #TODO bg-image only
-    let tok = getToken(cval)
-    if tok.tokenType == cttIdent and tok.value.equalsIgnoreCase("none"):
+    let tok = CSSToken(cval)
+    if tok.t == cttIdent and tok.value.equalsIgnoreCase("none"):
       return ok(CSSContent(t: ContentNone))
   let url = cssURL(cval, src = true)
   if url.isSome:
@@ -1161,17 +1155,17 @@ func cssImage(cval: CSSComponentValue): Opt[CSSContent] =
   return err()
 
 func cssInteger(cval: CSSComponentValue; range: Slice[int]): Opt[int] =
-  if isToken(cval):
-    let tok = getToken(cval)
-    if tok.tokenType == cttNumber:
+  if cval of CSSToken:
+    let tok = CSSToken(cval)
+    if tok.t == cttNumber:
       if tok.nvalue in float64(range.a)..float64(range.b):
         return ok(int(tok.nvalue))
   return err()
 
 func cssNumber(cval: CSSComponentValue; positive: bool): Opt[float64] =
-  if isToken(cval):
-    let tok = getToken(cval)
-    if tok.tokenType == cttNumber:
+  if cval of CSSToken:
+    let tok = CSSToken(cval)
+    if tok.t == cttNumber:
       if not positive or tok.nvalue >= 0:
         return ok(tok.nvalue)
   return err()
@@ -1430,7 +1424,7 @@ proc parseComputedValues*(res: var seq[CSSComputedEntry]; name: string;
         inc i
         cvals.skipWhitespace(i)
         if i < cvals.len:
-          if not cvals[i].isToken:
+          if not (cvals[i] of CSSToken):
             return err()
           if (let r = cssNumber(cvals[i], positive = true); r.isSome):
             # flex-shrink
diff --git a/src/css/mediaquery.nim b/src/css/mediaquery.nim
index 433212b1..756a67e4 100644
--- a/src/css/mediaquery.nim
+++ b/src/css/mediaquery.nim
@@ -52,12 +52,9 @@ type
       feature*: MediaFeature
     of mctNot:
       n*: MediaQuery
-    of mctOr:
-      ora*: MediaQuery
-      orb*: MediaQuery
-    of mctAnd:
-      anda*: MediaQuery
-      andb*: MediaQuery
+    of mctOr, mctAnd:
+      left*: MediaQuery
+      right*: MediaQuery
 
   MediaQueryList* = seq[MediaQuery]
 
@@ -97,8 +94,8 @@ func `$`*(mq: MediaQuery): string =
   of mctMedia: return $mq.media
   of mctFeature: return $mq.feature
   of mctNot: return "not (" & $mq.n
-  of mctOr: return "(" & $mq.ora & ") or (" & $mq.orb & ")"
-  of mctAnd: return "(" & $mq.anda & ") or (" & $mq.andb & ")"
+  of mctOr: return "(" & $mq.left & ") or (" & $mq.right & ")"
+  of mctAnd: return "(" & $mq.left & ") or (" & $mq.right & ")"
 
 const RangeFeatures = {mftColor, mftWidth, mftHeight}
 
@@ -124,7 +121,7 @@ proc peek(parser: MediaQueryParser; i = 0): CSSComponentValue =
 proc skipBlanks(parser: var MediaQueryParser) =
   while parser.has():
     let cval = parser.peek()
-    if cval of CSSToken and CSSToken(cval).tokenType == cttWhitespace:
+    if cval of CSSToken and CSSToken(cval).t == cttWhitespace:
       inc parser.at
     else:
       break
@@ -159,14 +156,14 @@ proc consumeToken(parser: var MediaQueryParser): Opt[CSSToken] =
 
 proc consumeIdent(parser: var MediaQueryParser): Opt[CSSToken] =
   let tok = ?parser.consumeToken()
-  if tok.tokenType != cttIdent:
+  if tok.t != cttIdent:
     parser.reconsume()
     return err()
   return ok(tok)
 
 proc consumeInt(parser: var MediaQueryParser): Opt[int] =
   let tok = ?parser.consumeToken()
-  if tok.tokenType != cttNumber or tok.tflagb == tflagbInteger:
+  if tok.t != cttNumber or tok.tflagb == tflagbInteger:
     parser.reconsume()
     return err()
   return ok(int(tok.nvalue))
@@ -299,9 +296,9 @@ proc parseFeature(parser: var MediaQueryParser; t: MediaFeatureType;
   if not parser.has():
     return getBoolFeature(t)
   let tok = ?parser.consumeToken()
-  if t notin RangeFeatures and (tok.tokenType != cttColon or ismin or ismax):
+  if t notin RangeFeatures and (tok.t != cttColon or ismin or ismax):
     return err()
-  if tok.tokenType != cttColon:
+  if tok.t != cttColon:
     # for range parsing; e.g. we might have gotten a delim or similar
     parser.reconsume()
   ?parser.skipBlanksCheckHas()
@@ -313,7 +310,7 @@ proc parseFeature(parser: var MediaQueryParser; t: MediaFeatureType;
 
 proc parseMediaInParens(parser: var MediaQueryParser): Opt[MediaQuery] =
   let sb = ?parser.consumeSimpleBlock()
-  if sb.token.tokenType != cttLparen:
+  if sb.token.t != cttLparen:
     return err()
   var fparser = MediaQueryParser(cvals: sb.value)
   fparser.skipBlanks()
@@ -334,12 +331,12 @@ proc parseMediaInParens(parser: var MediaQueryParser): Opt[MediaQuery] =
 proc parseMediaOr(parser: var MediaQueryParser; left: MediaQuery):
     Opt[MediaQuery] =
   let right = ?parser.parseMediaCondition()
-  return ok(MediaQuery(t: mctOr, ora: left, orb: right))
+  return ok(MediaQuery(t: mctOr, left: left, right: right))
 
 proc parseMediaAnd(parser: var MediaQueryParser; left: MediaQuery):
     Opt[MediaQuery] =
   let right = ?parser.parseMediaCondition()
-  return ok(MediaQuery(t: mctAnd, anda: left, andb: right))
+  return ok(MediaQuery(t: mctAnd, left: left, right: right))
 
 func negateIf(mq: MediaQuery; non: bool): MediaQuery =
   if non:
diff --git a/src/css/selectorparser.nim b/src/css/selectorparser.nim
index ef772ae7..f75d6570 100644
--- a/src/css/selectorparser.nim
+++ b/src/css/selectorparser.nim
@@ -300,7 +300,7 @@ proc parseNthChild(state: var SelectorParser; cssfunction: CSSFunction;
   if i >= cssfunction.value.len:
     return nthchild
   let lasttok = get_tok cssfunction.value[i]
-  if lasttok.tokenType != cttIdent or not lasttok.value.equalsIgnoreCase("of"):
+  if lasttok.t != cttIdent or not lasttok.value.equalsIgnoreCase("of"):
     fail
   if i == cssfunction.value.len: fail
   nthchild.pseudo.ofsels = cssfunction.value[i..^1]
@@ -310,7 +310,7 @@ proc parseNthChild(state: var SelectorParser; cssfunction: CSSFunction;
 
 proc skipWhitespace(state: var SelectorParser) =
   while state.has() and state.peek() of CSSToken and
-      CSSToken(state.peek()).tokenType == cttWhitespace:
+      CSSToken(state.peek()).t == cttWhitespace:
     inc state.at
 
 proc parseLang(cvals: seq[CSSComponentValue]): Selector =
@@ -318,7 +318,7 @@ proc parseLang(cvals: seq[CSSComponentValue]): Selector =
   state.skipWhitespace()
   if not state.has(): fail
   let tok = get_tok state.consume()
-  if tok.tokenType != cttIdent: fail
+  if tok.t != cttIdent: fail
   return Selector(t: stPseudoClass, pseudo: PseudoData(t: pcLang, s: tok.value))
 
 proc parseSelectorFunction(state: var SelectorParser; cssfunction: CSSFunction):
@@ -350,7 +350,7 @@ proc parsePseudoSelector(state: var SelectorParser): Selector =
       if state.nested or state.has() and state.peek() != cttComma: fail
       return Selector(t: stPseudoElement, elem: element)
     let tok = CSSToken(cval)
-    case tok.tokenType
+    case tok.t
     of cttIdent:
       template add_pseudo_class(class: PseudoClass) =
         return Selector(t: stPseudoClass, pseudo: PseudoData(t: class))
@@ -370,7 +370,7 @@ proc parsePseudoSelector(state: var SelectorParser): Selector =
     of cttColon:
       if not state.has(): fail
       let tok = get_tok state.consume()
-      if tok.tokenType != cttIdent: fail
+      if tok.t != cttIdent: fail
       case tok.value.toLowerAscii()
       of "before": add_pseudo_element peBefore
       of "after": add_pseudo_element peAfter
@@ -384,12 +384,12 @@ proc parseComplexSelector(state: var SelectorParser): ComplexSelector
 
 proc parseAttributeSelector(state: var SelectorParser;
     cssblock: CSSSimpleBlock): Selector =
-  if cssblock.token.tokenType != cttLbracket: fail
+  if cssblock.token.t != cttLbracket: fail
   var state2 = SelectorParser(cvals: cssblock.value)
   state2.skipWhitespace()
   if not state2.has(): fail
   let attr = get_tok state2.consume()
-  if attr.tokenType != cttIdent: fail
+  if attr.t != cttIdent: fail
   state2.skipWhitespace()
   if not state2.has():
     return Selector(
@@ -398,7 +398,7 @@ proc parseAttributeSelector(state: var SelectorParser;
       rel: SelectorRelation(t: rtExists)
     )
   let delim = get_tok state2.consume()
-  if delim.tokenType != cttDelim: fail
+  if delim.t != cttDelim: fail
   let rel = case delim.cvalue
   of '~': rtToken
   of '|': rtBeginDash
@@ -409,16 +409,16 @@ proc parseAttributeSelector(state: var SelectorParser;
   else: fail
   if rel != rtEquals:
     let delim = get_tok state2.consume()
-    if delim.tokenType != cttDelim or delim.cvalue != '=': fail
+    if delim.t != cttDelim or delim.cvalue != '=': fail
   state2.skipWhitespace()
   if not state2.has(): fail
   let value = get_tok state2.consume()
-  if value.tokenType notin {cttIdent, cttString}: fail
+  if value.t notin {cttIdent, cttString}: fail
   state2.skipWhitespace()
   var flag = rfNone
   if state2.has():
     let delim = get_tok state2.consume()
-    if delim.tokenType != cttIdent: fail
+    if delim.t != cttIdent: fail
     if delim.value.equalsIgnoreCase("i"):
       flag = rfI
     elif delim.value.equalsIgnoreCase("s"):
@@ -436,7 +436,7 @@ proc parseAttributeSelector(state: var SelectorParser;
 proc parseClassSelector(state: var SelectorParser): Selector =
   if not state.has(): fail
   let tok = get_tok state.consume()
-  if tok.tokenType != cttIdent: fail
+  if tok.t != cttIdent: fail
   let class = state.factory.toAtom(tok.value)
   result = Selector(t: stClass, class: class)
   when defined(debug):
@@ -448,7 +448,7 @@ proc parseCompoundSelector(state: var SelectorParser): CompoundSelector =
     let cval = state.peek()
     if cval of CSSToken:
       let tok = CSSToken(cval)
-      case tok.tokenType
+      case tok.t
       of cttIdent:
         inc state.at
         let s = tok.value.toLowerAscii()
@@ -502,7 +502,7 @@ proc parseComplexSelector(state: var SelectorParser): ComplexSelector =
     if not state.has():
       break # finish
     let tok = get_tok state.consume()
-    case tok.tokenType
+    case tok.t
     of cttDelim:
       case tok.cvalue
       of '>': result[^1].ct = ctChild
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2025-06-22 16:53:38 +0000