path: root/src/config/config.nim

import std/options
import std/os
import std/strutils
import std/tables

import chagashi/charset
import config/chapath
import config/cookie
import config/mailcap
import config/mimetypes
import config/toml
import config/urimethodmap
import css/cssparser
import html/script
import io/dynstream
import monoucha/fromjs
import monoucha/javascript
import monoucha/jspropenumlist
import monoucha/jsregex
import monoucha/jstypes
import monoucha/quickjs
import monoucha/tojs
import server/headers
import types/cell
import types/color
import types/jscolor
import types/opt
import types/url
import utils/regexutils
import utils/twtstr

type
  ColorMode* = enum
    cmMonochrome = "monochrome"
    cmANSI = "ansi"
    cmEightBit = "eight-bit"
    cmTrueColor = "true-color"

  MetaRefresh* = enum
    mrNever = "never"
    mrAlways = "always"
    mrAsk = "ask"

  ImageMode* = enum
    imNone = "none"
    imSixel = "sixel"
    imKitty = "kitty"

  StyleString* = distinct string

  DeprecatedStyleString* = distinct string

  ChaPathResolved* = distinct string

  HeadlessMode* = enum
    hmFalse = "false"
    hmTrue = "true"
    hmDump = "dump"

  ActionMap = object
    t: Table[string, string]

  FormRequestType* = enum
    frtHttp = "http"
    frtFtp = "ftp"
    frtData = "data"
    frtMailto = "mailto"

  SiteConfig* = ref object
    url*: Option[Regex]
    host*: Option[Regex]
    rewriteUrl*: Option[JSValueFunction]
    shareCookieJar*: Option[string]
    stylesheet*: Option[DeprecatedStyleString]
    proxy*: Option[URL]
    defaultHeaders*: TableRef[string, string]
    cookie*: Option[CookieMode]
    refererFrom*: Option[bool]
    scripting*: Option[ScriptingMode]
    documentCharset*: seq[Charset]
    images*: Option[bool]
    styling*: Option[bool]
    insecureSslNoVerify*: Option[bool]
    autofocus*: Option[bool]
    metaRefresh*: Option[MetaRefresh]
    history*: Option[bool]
    markLinks*: Option[bool]
    userStyle*: Option[StyleString]

  OmniRule* = ref object
    match*: Regex
    substituteUrl*: Option[JSValueFunction]

  StartConfig = object
    visualHome* {.jsgetset.}: string
    startupScript* {.jsgetset.}: string
    headless* {.jsgetset.}: HeadlessMode
    consoleBuffer* {.jsgetset.}: bool

  CSSConfig = object
    stylesheet* {.jsgetset.}: string

  SearchConfig = object
    wrap* {.jsgetset.}: bool
    ignoreCase* {.jsgetset.}: Option[bool]

  EncodingConfig = object
    displayCharset* {.jsgetset.}: Option[Charset]
    documentCharset* {.jsgetset.}: seq[Charset]

  CommandConfig = object
    jsObj*: JSValue
    init*: seq[tuple[k, cmd: string]] # initial k/v map
    map*: Table[string, JSValue] # qualified name -> function

  ExternalConfig = object
    tmpdir* {.jsgetset.}: ChaPathResolved
    sockdir* {.jsgetset.}: ChaPathResolved
    editor* {.jsgetset.}: string
    mailcap*: Mailcap
    autoMailcap*: AutoMailcap
    mimeTypes*: MimeTypes
    cgiDir* {.jsgetset.}: seq[ChaPathResolved]
    urimethodmap*: URIMethodMap
    bookmark* {.jsgetset.}: ChaPathResolved
    historyFile*: ChaPathResolved
    historySize* {.jsgetset.}: int32
    cookieFile*: ChaPathResolved
    downloadDir* {.jsgetset.}: ChaPathResolved
    w3mCgiCompat* {.jsgetset.}: bool
    copyCmd* {.jsgetset.}: string
    pasteCmd* {.jsgetset.}: string

  InputConfig = object
    viNumericPrefix* {.jsgetset.}: bool
    useMouse* {.jsgetset.}: bool

  NetworkConfig = object
    maxRedirect* {.jsgetset.}: int32
    prependHttps* {.jsgetset.}: bool
    prependScheme* {.jsgetset.}: string
    proxy* {.jsgetset.}: URL
    defaultHeaders* {.jsgetset.}: Table[string, string]

  DisplayConfig = object
    colorMode* {.jsgetset.}: Option[ColorMode]
    formatMode* {.jsgetset.}: Option[set[FormatFlag]]
    noFormatMode* {.jsgetset.}: set[FormatFlag]
    imageMode* {.jsgetset.}: Option[ImageMode]
    sixelColors* {.jsgetset.}: Option[int32]
    altScreen* {.jsgetset.}: Option[bool]
    highlightColor* {.jsgetset.}: ARGBColor
    highlightMarks* {.jsgetset.}: bool
    doubleWidthAmbiguous* {.jsgetset.}: bool
    minimumContrast* {.jsgetset.}: int32
    forceClear* {.jsgetset.}: bool
    setTitle* {.jsgetset.}: bool
    defaultBackgroundColor* {.jsgetset.}: Option[RGBColor]
    defaultForegroundColor* {.jsgetset.}: Option[RGBColor]
    queryDa1* {.jsgetset.}: bool
    columns* {.jsgetset.}: int32
    lines* {.jsgetset.}: int32
    pixelsPerColumn* {.jsgetset.}: int32
    pixelsPerLine* {.jsgetset.}: int32
    forceColumns* {.jsgetset.}: bool
    forceLines* {.jsgetset.}: bool
    forcePixelsPerColumn* {.jsgetset.}: bool
    forcePixelsPerLine* {.jsgetset.}: bool

  ProtocolConfig* = ref object
    formRequest*: FormRequestType

  BufferSectionConfig* = object
    styling* {.jsgetset.}: bool
    scripting* {.jsgetset.}: ScriptingMode
    images* {.jsgetset.}: bool
    cookie* {.jsgetset.}: CookieMode
    refererFrom* {.jsgetset.}: bool
    autofocus* {.jsgetset.}: bool
    metaRefresh* {.jsgetset.}: MetaRefresh
    history* {.jsgetset.}: bool
    markLinks* {.jsgetset.}: bool
    userStyle*: StyleString #TODO getset

  Config* = ref object
    jsctx*: JSContext
    jsvfns*: seq[JSValueFunction]
    dir* {.jsget.}: string
    `include` {.jsget.}: seq[ChaPathResolved]
    start* {.jsget.}: StartConfig
    buffer* {.jsget.}: BufferSectionConfig
    search* {.jsget.}: SearchConfig
    css* {.jsget.}: CSSConfig
    encoding* {.jsget.}: EncodingConfig
    external* {.jsget.}: ExternalConfig
    network* {.jsget.}: NetworkConfig
    input* {.jsget.}: InputConfig
    display* {.jsget.}: DisplayConfig
    #TODO getset
    protocol*: Table[string, ProtocolConfig]
    siteconf*: seq[SiteConfig]
    omnirule*: seq[OmniRule]
    cmd*: CommandConfig
    page* {.jsget.}: ActionMap
    line* {.jsget.}: ActionMap

jsDestructor(ActionMap)
jsDestructor(StartConfig)
jsDestructor(CSSConfig)
jsDestructor(SearchConfig)
jsDestructor(EncodingConfig)
jsDestructor(ExternalConfig)
jsDestructor(NetworkConfig)
jsDestructor(DisplayConfig)
jsDestructor(BufferSectionConfig)
jsDestructor(Config)

converter toStr*(p: ChaPathResolved): string {.inline.} =
  return string(p)

proc fromJS(ctx: JSContext; val: JSValueConst; res: var ChaPathResolved):
    Opt[void] =
  return ctx.fromJS(val, string(res))

proc `[]=`(a: var ActionMap; b: string; c: sink string) =
  a.t[b] = c

# Can't be lent string on 2.0.4 yet.
template `[]`*(a: ActionMap; b: string): string =
  a.t[b]

proc contains*(a: ActionMap; b: string): bool =
  return b in a.t

proc getOrDefault(a: ActionMap; b: string): string =
  return a.t.getOrDefault(b)

func getRealKey(key: string): string =
  var realk = ""
  var control = 0
  var meta = 0
  var skip = false
  for c in key:
    if c == '\\':
      skip = true
    elif skip:
      realk &= c
      skip = false
    elif c == 'M' and meta == 0:
      inc meta
    elif c == 'C' and control == 0:
      inc control
    elif c == '-' and control == 1:
      inc control
    elif c == '-' and meta == 1:
      inc meta
    elif meta == 1:
      realk &= 'M' & c
      meta = 0
    elif control == 1:
      realk &= 'C' & c
      control = 0
    else:
      if meta == 2:
        realk &= '\e'
        meta = 0
      if control == 2:
        realk &= getControlChar(c)
        control = 0
      else:
        realk &= c
  if control == 1:
    realk &= 'C'
  if meta == 1:
    realk &= 'M'
  if skip:
    realk &= '\\'
  return realk

proc getter(ctx: JSContext; a: var ActionMap; s: string): JSValue
    {.jsgetownprop.} =
  a.t.withValue(s, p):
    return ctx.toJS(p[])
  return JS_NULL

proc setter(a: var ActionMap; k, v: string) {.jssetprop.} =
  let k = getRealKey(k)
  if k == "":
    return
  a[k] = v
  var teststr = k
  teststr.setLen(teststr.high)
  for i in countdown(k.high, 0):
    discard a.t.hasKeyOrPut(teststr, "window.feedNext()")
    teststr.setLen(i)

proc delete(a: var ActionMap; k: string): bool {.jsdelprop.} =
  let k = getRealKey(k)
  let ina = k in a
  a.t.del(k)
  return ina

func names(ctx: JSContext; a: var ActionMap): JSPropertyEnumList
    {.jspropnames.} =
  let L = uint32(a.t.len)
  var list = newJSPropertyEnumList(ctx, L)
  for key in a.t.keys:
    list.add(key)
  return list

proc bindPagerKey(config: Config; key, action: string) {.jsfunc.} =
  config.page.setter(key, action)

proc bindLineKey(config: Config; key, action: string) {.jsfunc.} =
  config.line.setter(key, action)

proc readUserStylesheet(outs: var string; dir, file: string): Err[string] =
  let x = ChaPath(file).unquote(dir)
  if x.isNone:
    return err(x.error)
  let ps = newPosixStream(x.get)
  if ps != nil:
    outs &= ps.readAll()
    ps.sclose()
  ok()

type ConfigParser = object
  config: Config
  dir: string
  warnings: seq[string]

proc parseConfigValue(ctx: var ConfigParser; x: var object; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var ref object; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var bool; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var string; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var ChaPath; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue[T](ctx: var ConfigParser; x: var seq[T]; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var Charset; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var int32; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var int64; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var ScriptingMode; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var HeadlessMode; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var CookieMode; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue[T](ctx: var ConfigParser; x: var Option[T]; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var ARGBColor; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var RGBColor; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var ActionMap; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var CSSConfig; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue[U; V](ctx: var ConfigParser; x: var Table[U, V];
  v: TomlValue; k: string): Err[string]
proc parseConfigValue[U; V](ctx: var ConfigParser; x: var TableRef[U, V];
  v: TomlValue; k: string): Err[string]
proc parseConfigValue[T](ctx: var ConfigParser; x: var set[T]; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var TomlTable; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var Regex; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var URL; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var JSValueFunction;
  v: TomlValue; k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var ChaPathResolved;
  v: TomlValue; k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var MimeTypes; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var Mailcap; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var AutoMailcap; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var URIMethodMap; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var CommandConfig; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var StyleString; v: TomlValue;
  k: string): Err[string]
proc parseConfigValue(ctx: var ConfigParser; x: var DeprecatedStyleString;
  v: TomlValue; k: string): Err[string]

proc typeCheck(v: TomlValue; t: TomlValueType; k: string): Err[string] =
  if v.t != t:
    return err(k & ": invalid type (got " & $v.t & ", expected " & $t & ")")
  ok()

proc typeCheck(v: TomlValue; t: set[TomlValueType]; k: string): Err[string] =
  if v.t notin t:
    return err(k & ": invalid type (got " & $v.t & ", expected " & $t & ")")
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var object; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtTable, k)
  for fk, fv in x.fieldPairs:
    when typeof(fv) isnot JSContext|seq[JSValueFunction]:
      let kebabk = camelToKebabCase(fk)
      if kebabk in v:
        let kkk = if k != "":
          k & "." & fk
        else:
          fk
        ?ctx.parseConfigValue(fv, v[kebabk], kkk)
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var ref object; v: TomlValue;
    k: string): Err[string] =
  new(x)
  ctx.parseConfigValue(x[], v, k)

proc parseConfigValue[U, V](ctx: var ConfigParser; x: var Table[U, V];
    v: TomlValue; k: string): Err[string] =
  ?typeCheck(v, tvtTable, k)
  x.clear()
  for kk, vv in v:
    var y: V
    let kkk = k & "[" & kk & "]"
    ?ctx.parseConfigValue(y, vv, kkk)
    x[kk] = y
  ok()

proc parseConfigValue[U, V](ctx: var ConfigParser; x: var TableRef[U, V];
    v: TomlValue; k: string): Err[string] =
  ?typeCheck(v, tvtTable, k)
  x = TableRef[U, V]()
  for kk, vv in v:
    var y: V
    let kkk = k & "[" & kk & "]"
    ?ctx.parseConfigValue(y, vv, kkk)
    x[kk] = y
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var bool; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtBoolean, k)
  x = v.b
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var string; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  x = v.s
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var ChaPath;
    v: TomlValue; k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  x = ChaPath(v.s)
  ok()

proc parseConfigValue[T](ctx: var ConfigParser; x: var seq[T]; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, {tvtString, tvtArray}, k)
  if v.t != tvtArray:
    var y: T
    ?ctx.parseConfigValue(y, v, k)
    x = @[y]
  else:
    if not v.ad:
      x.setLen(0)
    for i in 0 ..< v.a.len:
      var y: T
      ?ctx.parseConfigValue(y, v.a[i], k & "[" & $i & "]")
      x.add(y)
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var TomlTable; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, {tvtTable}, k)
  x = v.tab
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var Charset; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  x = getCharset(v.s)
  if x == CHARSET_UNKNOWN:
    return err(k & ": unknown charset '" & v.s & "'")
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var int32; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtInteger, k)
  x = int32(v.i)
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var int64; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtInteger, k)
  x = v.i
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var ScriptingMode; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, {tvtString, tvtBoolean}, k)
  if v.t == tvtBoolean:
    x = if v.b: smTrue else: smFalse
  elif v.s == "app":
    x = smApp
  else:
    return err(k & ": unknown scripting mode '" & v.s & "'")
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var HeadlessMode; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, {tvtString, tvtBoolean}, k)
  if v.t == tvtBoolean:
    x = if v.b: hmTrue else: hmFalse
  elif v.s == "dump":
    x = hmDump
  else:
    return err(k & ": unknown headless mode '" & v.s & "'")
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var CookieMode; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, {tvtString, tvtBoolean}, k)
  if v.t == tvtBoolean:
    x = if v.b: cmReadOnly else: cmNone
  elif v.s == "save":
    x = cmSave
  else:
    return err(k & ": unknown cookie mode '" & v.s & "'")
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var ARGBColor; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  let c = parseARGBColor(v.s)
  if c.isNone:
    return err(k & ": invalid color '" & v.s & "'")
  x = c.get
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var RGBColor; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  let c = parseLegacyColor(v.s)
  if c.isNone:
    return err(k & ": invalid color '" & v.s & "'")
  x = c.get
  ok()

proc parseConfigValue[T](ctx: var ConfigParser; x: var Option[T]; v: TomlValue;
    k: string): Err[string] =
  if v.t == tvtString and v.s == "auto":
    x = none(T)
  else:
    var y: T
    ?ctx.parseConfigValue(y, v, k)
    x = some(y)
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var ActionMap; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtTable, k)
  for kk, vv in v:
    ?typeCheck(vv, tvtString, k & "[" & kk & "]")
    let rk = getRealKey(kk)
    var buf = ""
    for c in rk.toOpenArray(0, rk.high - 1):
      buf &= c
      x[buf] = "window.feedNext()"
    x[rk] = vv.s
  ok()

proc parseConfigValue[T: enum](ctx: var ConfigParser; x: var T; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  let e = strictParseEnum[T](v.s)
  if e.isNone:
    return err(k & ": invalid value '" & v.s & "'")
  x = e.get
  ok()

proc parseConfigValue[T](ctx: var ConfigParser; x: var set[T]; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, {tvtString, tvtArray}, k)
  if v.t == tvtString:
    var xx: T
    ?ctx.parseConfigValue(xx, v, k)
    x = {xx}
  else:
    x = {}
    for i in 0 ..< v.a.len:
      let kk = k & "[" & $i & "]"
      var xx: T
      ?ctx.parseConfigValue(xx, v.a[i], kk)
      x.incl(xx)
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var CSSConfig; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtTable, k)
  ctx.warnings.add("[css] is deprecated; use buffer.user-style instead")
  for kk, vv in v:
    let kkk = if k != "":
      k & "." & kk
    else:
      kk
    case kk
    of "include":
      ?typeCheck(vv, {tvtString, tvtArray}, kkk)
      case vv.t
      of tvtString:
        ?x.stylesheet.readUserStylesheet(ctx.dir, vv.s)
      of tvtArray:
        for child in vv.a:
          ?x.stylesheet.readUserStylesheet(ctx.dir, vv.s)
      else: discard
    of "inline":
      ?typeCheck(vv, tvtString, kkk)
      x.stylesheet &= vv.s
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var Regex; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  let y = compileMatchRegex(v.s)
  if y.isNone:
    return err(k & ": invalid regex (" & y.error & ")")
  x = y.get
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var URL; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  let y = parseURL(v.s)
  if y.isNone:
    return err(k & ": invalid URL " & v.s)
  x = y.get
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var JSValueFunction;
    v: TomlValue; k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  let fun = ctx.config.jsctx.eval(v.s, "<config>", JS_EVAL_TYPE_GLOBAL)
  if JS_IsException(fun):
    return err(k & ": " & ctx.config.jsctx.getExceptionMsg())
  if not JS_IsFunction(ctx.config.jsctx, fun):
    return err(k & ": not a function")
  x = JSValueFunction(fun: fun)
  ctx.config.jsvfns.add(x) # so we can clean it up on exit
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var ChaPathResolved;
    v: TomlValue; k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  let y = ChaPath(v.s).unquote(ctx.config.dir)
  if y.isNone:
    return err(k & ": " & y.error)
  x = ChaPathResolved(y.get)
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var MimeTypes; v: TomlValue;
    k: string): Err[string] =
  var paths: seq[ChaPathResolved]
  ?ctx.parseConfigValue(paths, v, k)
  x = MimeTypes.default
  for p in paths:
    let ps = newPosixStream(p)
    if ps != nil:
      let src = ps.readAllOrMmap()
      x.parseMimeTypes(src.toOpenArray(), DefaultImages)
      deallocMem(src)
      ps.sclose()
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var Mailcap; v: TomlValue;
    k: string): Err[string] =
  var paths: seq[ChaPathResolved]
  ?ctx.parseConfigValue(paths, v, k)
  x = Mailcap.default
  for p in paths:
    let ps = newPosixStream(p)
    if ps != nil:
      let src = ps.readAllOrMmap()
      let res = x.parseMailcap(src.toOpenArray(), p)
      deallocMem(src)
      ps.sclose()
      if res.isNone:
        ctx.warnings.add(res.error)
  ok()

const DefaultMailcap = block:
  var mailcap: Mailcap
  doAssert mailcap.parseMailcap(staticRead"res/mailcap", "res/mailcap").isSome
  mailcap

proc parseConfigValue(ctx: var ConfigParser; x: var AutoMailcap;
    v: TomlValue; k: string): Err[string] =
  var path: ChaPathResolved
  ?ctx.parseConfigValue(path, v, k)
  x = AutoMailcap(path: path)
  let ps = newPosixStream(path)
  if ps != nil:
    let src = ps.readAllOrMmap()
    let res = x.entries.parseMailcap(src.toOpenArray(), path)
    deallocMem(src)
    ps.sclose()
    if res.isNone:
      ctx.warnings.add(res.error)
  x.entries.add(DefaultMailcap)
  ok()

const DefaultURIMethodMap = parseURIMethodMap(staticRead"res/urimethodmap")

proc parseConfigValue(ctx: var ConfigParser; x: var URIMethodMap; v: TomlValue;
    k: string): Err[string] =
  var paths: seq[ChaPathResolved]
  ?ctx.parseConfigValue(paths, v, k)
  x = URIMethodMap.default
  for p in paths:
    let ps = newPosixStream(p)
    if ps != nil:
      x.parseURIMethodMap(ps.readAll())
      ps.sclose()
  x.append(DefaultURIMethodMap)
  ok()

func isCompatibleIdent(s: string): bool =
  if s.len == 0 or s[0] notin AsciiAlpha + {'_', '$'}:
    return false
  for i in 1 ..< s.len:
    if s[i] notin AsciiAlphaNumeric + {'_', '$'}:
      return false
  return true

proc parseConfigValue(ctx: var ConfigParser; x: var CommandConfig; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtTable, k)
  for kk, vv in v:
    let kkk = k & "." & kk
    ?typeCheck(vv, {tvtTable, tvtString}, kkk)
    if not kk.isCompatibleIdent():
      return err(kkk & ": invalid command name")
    if vv.t == tvtTable:
      ?ctx.parseConfigValue(x, vv, kkk)
    else: # tvtString
      x.init.add((kkk.substr("cmd.".len), vv.s))
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var StyleString; v: TomlValue;
    k: string): Err[string] =
  ?typeCheck(v, tvtString, k)
  var s = v.s
  var i = 0
  var y = ""
  while s.nextCSSToken(i):
    if s[i] in AsciiWhitespace or
        i + 1 < s.len and s[i] == '\\' and s[i + 1] == '\n':
      inc i
      continue
    if not s.toOpenArray(i, s.high).startsWithIgnoreCase("@import"):
      break
    i += "@import".len
    if i >= s.len or s[i] notin AsciiWhitespace:
      break
    i = s.skipBlanks(i)
    if i >= s.len or s[i] notin {'"', '\''}:
      break
    let ending = s[i]
    inc i
    let tok = s.consumeCSSString(ending, i)
    if tok.t != cttString:
      break
    while s.nextCSSToken(i):
      if s[i] in AsciiWhitespace or
          i + 1 < s.len and s[i] == '\\' and s[i + 1] == '\n':
        inc i
        continue
      break
    if i < s.len and s[i] != ';':
      break
    let path = ChaPath(tok.value).unquote(ctx.config.dir)
    if path.isNone:
      return err(k & ": wrong CSS import (" & $tok.value &
        " is not a valid path)")
    let ps = newPosixStream(path.get)
    if ps == nil:
      return err(k & ": wrong CSS import (file " & $tok.value & " not found)")
    y &= ps.readAll()
    inc i
  y &= s.substr(i)
  x = StyleString(move(y))
  ok()

proc parseConfigValue(ctx: var ConfigParser; x: var DeprecatedStyleString;
    v: TomlValue; k: string): Err[string] =
  ctx.warnings.add(k & ": stylesheet is deprecated; use user-style instead")
  ctx.parseConfigValue(string(x), v, k)

proc parseConfig*(config: Config; dir: string; buf: openArray[char];
  warnings: var seq[string]; name = "<input>"; laxnames = false): Err[string]

proc parseConfig(config: Config; dir: string; t: TomlValue;
    warnings: var seq[string]): Err[string] =
  var ctx = ConfigParser(config: config, dir: dir)
  ?ctx.parseConfigValue(config[], t, "")
  #TODO: for omnirule/siteconf, check if substitution rules are specified?
  while config.`include`.len > 0:
    #TODO: warn about recursive includes
    var includes = config.`include`
    config.`include`.setLen(0)
    for s in includes:
      let ps = newPosixStream(s)
      if ps == nil:
        return err("include file not found: " & s)
      ?config.parseConfig(dir, ps.readAll(), warnings)
      ps.sclose()
  warnings.add(ctx.warnings)
  ok()

proc parseConfig*(config: Config; dir: string; buf: openArray[char];
    warnings: var seq[string]; name = "<input>"; laxnames = false):
    Err[string] =
  let toml = parseToml(buf, dir / name, laxnames)
  if toml.isSome:
    return config.parseConfig(dir, toml.get, warnings)
  return err("Fatal error: failed to parse config\n" & toml.error)

proc getNormalAction*(config: Config; s: string): string =
  return config.page.getOrDefault(s)

proc getLinedAction*(config: Config; s: string): string =
  return config.line.getOrDefault(s)

proc openConfig*(dir: var string; override: Option[string];
    warnings: var seq[string]): PosixStream =
  if override.isSome:
    if override.get.len > 0 and override.get[0] == '/':
      dir = parentDir(override.get)
      return newPosixStream(override.get)
    else:
      let path = getCurrentDir() / override.get
      dir = parentDir(path)
      return newPosixStream(path)
  dir = getEnv("CHA_DIR")
  if dir != "":
    return newPosixStream(dir / "config.toml")
  dir = getEnv("CHA_CONFIG_DIR")
  if dir != "":
    warnings.add("CHA_CONFIG_DIR is deprecated; use CHA_DIR instead")
    return newPosixStream(dir / "config.toml")
  dir = getEnv("XDG_CONFIG_HOME")
  if dir != "":
    dir = dir / "chawan"
    return newPosixStream(dir / "config.toml")
  dir = expandPath("~/.config/chawan")
  if (let fs = newPosixStream(dir / "config.toml"); fs != nil):
    return fs
  dir = expandPath("~/.chawan")
  return newPosixStream(dir / "config.toml")

# called after parseConfig returns
proc initCommands*(config: Config): Err[string] =
  let ctx = config.jsctx
  let obj = JS_NewObject(ctx)
  defer: JS_FreeValue(ctx, obj)
  if JS_IsException(obj):
    return err(ctx.getExceptionMsg())
  for i in countdown(config.cmd.init.high, 0):
    let (k, cmd) = config.cmd.init[i]
    if k in config.cmd.map:
      # already in map; skip
      continue
    var objIt = JS_DupValue(ctx, obj)
    let name = k.afterLast('.')
    if name.len < k.len:
      for ss in k.substr(0, k.high - name.len - 1).split('.'):
        var prop = JS_GetPropertyStr(ctx, objIt, cstring(ss))
        if JS_IsUndefined(prop):
          prop = JS_NewObject(ctx)
          case ctx.definePropertyE(objIt, ss, JS_DupValue(ctx, prop))
          of dprException: return err(ctx.getExceptionMsg())
          else: discard
        if JS_IsException(prop):
          return err(ctx.getExceptionMsg())
        JS_FreeValue(ctx, objIt)
        objIt = prop
    if cmd == "":
      config.cmd.map[k] = JS_UNDEFINED
      continue
    let fun = ctx.eval(cmd, "<" & k & ">", JS_EVAL_TYPE_GLOBAL)
    if JS_IsException(fun):
      return err(ctx.getExceptionMsg())
    if not JS_IsFunction(ctx, fun):
      JS_FreeValue(ctx, fun)
      return err(k & " is not a function")
    case ctx.definePropertyE(objIt, name, JS_DupValue(ctx, fun))
    of dprException: return err(ctx.getExceptionMsg())
    else: discard
    config.cmd.map[k] = fun
    JS_FreeValue(ctx, objIt)
  config.cmd.jsObj = JS_DupValue(ctx, obj)
  config.cmd.init = @[]
  ok()

proc addConfigModule*(ctx: JSContext) =
  ctx.registerType(ActionMap)
  ctx.registerType(StartConfig)
  ctx.registerType(CSSConfig)
  ctx.registerType(SearchConfig)
  ctx.registerType(EncodingConfig)
  ctx.registerType(ExternalConfig)
  ctx.registerType(NetworkConfig)
  ctx.registerType(DisplayConfig)
  ctx.registerType(BufferSectionConfig, name = "BufferConfig")
  ctx.registerType(Config)