doc: patch

Reviewed-on: #4

Dockerfile

@@ -0,0 +1,9 @@
+FROM alpine:3.20
+
+ARG SITE
+
+RUN echo "https://git.vxserver.dev/api/packages/fSD/alpine/main/fports" >> /etc/apk/repositories
+    && apk update \
+    && apk add --no-cache fes
+
+ENTRYPOINT ["fes", "run", ${SITE}]

core/dkjson.lua

@@ -0,0 +1,752 @@
+-- Module options:
+local always_use_lpeg = false
+local register_global_module_table = false
+local global_module_name = 'json'
+
+--[==[
+
+David Kolf's JSON module for Lua 5.1 - 5.4
+
+Version 2.8
+
+
+For the documentation see the corresponding readme.txt or visit
+<http://dkolf.de/dkjson-lua/>.
+
+You can contact the author by sending an e-mail to 'david' at the
+domain 'dkolf.de'.
+
+
+Copyright (C) 2010-2024 David Heiko Kolf
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--]==]
+
+-- global dependencies:
+local pairs, type, tostring, tonumber, getmetatable, setmetatable =
+      pairs, type, tostring, tonumber, getmetatable, setmetatable
+local error, require, pcall, select = error, require, pcall, select
+local floor, huge = math.floor, math.huge
+local strrep, gsub, strsub, strbyte, strchar, strfind, strlen, strformat =
+      string.rep, string.gsub, string.sub, string.byte, string.char,
+      string.find, string.len, string.format
+local strmatch = string.match
+local concat = table.concat
+
+local json = { version = "dkjson 2.8" }
+
+local jsonlpeg = {}
+
+if register_global_module_table then
+  if always_use_lpeg then
+    _G[global_module_name] = jsonlpeg
+  else
+    _G[global_module_name] = json
+  end
+end
+
+local _ENV = nil -- blocking globals in Lua 5.2 and later
+
+pcall (function()
+  -- Enable access to blocked metatables.
+  -- Don't worry, this module doesn't change anything in them.
+  local debmeta = require "debug".getmetatable
+  if debmeta then getmetatable = debmeta end
+end)
+
+json.null = setmetatable ({}, {
+  __tojson = function () return "null" end
+})
+
+local function isarray (tbl)
+  local max, n, arraylen = 0, 0, 0
+  for k,v in pairs (tbl) do
+    if k == 'n' and type(v) == 'number' then
+      arraylen = v
+      if v > max then
+        max = v
+      end
+    else
+      if type(k) ~= 'number' or k < 1 or floor(k) ~= k then
+        return false
+      end
+      if k > max then
+        max = k
+      end
+      n = n + 1
+    end
+  end
+  if max > 10 and max > arraylen and max > n * 2 then
+    return false -- don't create an array with too many holes
+  end
+  return true, max
+end
+
+local escapecodes = {
+  ["\""] = "\\\"", ["\\"] = "\\\\", ["\b"] = "\\b", ["\f"] = "\\f",
+  ["\n"] = "\\n",  ["\r"] = "\\r",  ["\t"] = "\\t"
+}
+
+local function escapeutf8 (uchar)
+  local value = escapecodes[uchar]
+  if value then
+    return value
+  end
+  local a, b, c, d = strbyte (uchar, 1, 4)
+  a, b, c, d = a or 0, b or 0, c or 0, d or 0
+  if a <= 0x7f then
+    value = a
+  elseif 0xc0 <= a and a <= 0xdf and b >= 0x80 then
+    value = (a - 0xc0) * 0x40 + b - 0x80
+  elseif 0xe0 <= a and a <= 0xef and b >= 0x80 and c >= 0x80 then
+    value = ((a - 0xe0) * 0x40 + b - 0x80) * 0x40 + c - 0x80
+  elseif 0xf0 <= a and a <= 0xf7 and b >= 0x80 and c >= 0x80 and d >= 0x80 then
+    value = (((a - 0xf0) * 0x40 + b - 0x80) * 0x40 + c - 0x80) * 0x40 + d - 0x80
+  else
+    return ""
+  end
+  if value <= 0xffff then
+    return strformat ("\\u%.4x", value)
+  elseif value <= 0x10ffff then
+    -- encode as UTF-16 surrogate pair
+    value = value - 0x10000
+    local highsur, lowsur = 0xD800 + floor (value/0x400), 0xDC00 + (value % 0x400)
+    return strformat ("\\u%.4x\\u%.4x", highsur, lowsur)
+  else
+    return ""
+  end
+end
+
+local function fsub (str, pattern, repl)
+  -- gsub always builds a new string in a buffer, even when no match
+  -- exists. First using find should be more efficient when most strings
+  -- don't contain the pattern.
+  if strfind (str, pattern) then
+    return gsub (str, pattern, repl)
+  else
+    return str
+  end
+end
+
+local function quotestring (value)
+  -- based on the regexp "escapable" in https://github.com/douglascrockford/JSON-js
+  value = fsub (value, "[%z\1-\31\"\\\127]", escapeutf8)
+  if strfind (value, "[\194\216\220\225\226\239]") then
+    value = fsub (value, "\194[\128-\159\173]", escapeutf8)
+    value = fsub (value, "\216[\128-\132]", escapeutf8)
+    value = fsub (value, "\220\143", escapeutf8)
+    value = fsub (value, "\225\158[\180\181]", escapeutf8)
+    value = fsub (value, "\226\128[\140-\143\168-\175]", escapeutf8)
+    value = fsub (value, "\226\129[\160-\175]", escapeutf8)
+    value = fsub (value, "\239\187\191", escapeutf8)
+    value = fsub (value, "\239\191[\176-\191]", escapeutf8)
+  end
+  return "\"" .. value .. "\""
+end
+json.quotestring = quotestring
+
+local function replace(str, o, n)
+  local i, j = strfind (str, o, 1, true)
+  if i then
+    return strsub(str, 1, i-1) .. n .. strsub(str, j+1, -1)
+  else
+    return str
+  end
+end
+
+-- locale independent num2str and str2num functions
+local decpoint, numfilter
+
+local function updatedecpoint ()
+  decpoint = strmatch(tostring(0.5), "([^05+])")
+  -- build a filter that can be used to remove group separators
+  numfilter = "[^0-9%-%+eE" .. gsub(decpoint, "[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%0") .. "]+"
+end
+
+updatedecpoint()
+
+local function num2str (num)
+  return replace(fsub(tostring(num), numfilter, ""), decpoint, ".")
+end
+
+local function str2num (str)
+  local num = tonumber(replace(str, ".", decpoint))
+  if not num then
+    updatedecpoint()
+    num = tonumber(replace(str, ".", decpoint))
+  end
+  return num
+end
+
+local function addnewline2 (level, buffer, buflen)
+  buffer[buflen+1] = "\n"
+  buffer[buflen+2] = strrep ("  ", level)
+  buflen = buflen + 2
+  return buflen
+end
+
+function json.addnewline (state)
+  if state.indent then
+    state.bufferlen = addnewline2 (state.level or 0,
+                           state.buffer, state.bufferlen or #(state.buffer))
+  end
+end
+
+local encode2 -- forward declaration
+
+local function addpair (key, value, prev, indent, level, buffer, buflen, tables, globalorder, state)
+  local kt = type (key)
+  if kt ~= 'string' and kt ~= 'number' then
+    return nil, "type '" .. kt .. "' is not supported as a key by JSON."
+  end
+  if prev then
+    buflen = buflen + 1
+    buffer[buflen] = ","
+  end
+  if indent then
+    buflen = addnewline2 (level, buffer, buflen)
+  end
+  -- When Lua is compiled with LUA_NOCVTN2S this will fail when
+  -- numbers are mixed into the keys of the table. JSON keys are always
+  -- strings, so this would be an implicit conversion too and the failure
+  -- is intentional.
+  buffer[buflen+1] = quotestring (key)
+  buffer[buflen+2] = ":"
+  return encode2 (value, indent, level, buffer, buflen + 2, tables, globalorder, state)
+end
+
+local function appendcustom(res, buffer, state)
+  local buflen = state.bufferlen
+  if type (res) == 'string' then
+    buflen = buflen + 1
+    buffer[buflen] = res
+  end
+  return buflen
+end
+
+local function exception(reason, value, state, buffer, buflen, defaultmessage)
+  defaultmessage = defaultmessage or reason
+  local handler = state.exception
+  if not handler then
+    return nil, defaultmessage
+  else
+    state.bufferlen = buflen
+    local ret, msg = handler (reason, value, state, defaultmessage)
+    if not ret then return nil, msg or defaultmessage end
+    return appendcustom(ret, buffer, state)
+  end
+end
+
+function json.encodeexception(reason, value, state, defaultmessage)
+  return quotestring("<" .. defaultmessage .. ">")
+end
+
+encode2 = function (value, indent, level, buffer, buflen, tables, globalorder, state)
+  local valtype = type (value)
+  local valmeta = getmetatable (value)
+  valmeta = type (valmeta) == 'table' and valmeta -- only tables
+  local valtojson = valmeta and valmeta.__tojson
+  if valtojson then
+    if tables[value] then
+      return exception('reference cycle', value, state, buffer, buflen)
+    end
+    tables[value] = true
+    state.bufferlen = buflen
+    local ret, msg = valtojson (value, state)
+    if not ret then return exception('custom encoder failed', value, state, buffer, buflen, msg) end
+    tables[value] = nil
+    buflen = appendcustom(ret, buffer, state)
+  elseif value == nil then
+    buflen = buflen + 1
+    buffer[buflen] = "null"
+  elseif valtype == 'number' then
+    local s
+    if value ~= value or value >= huge or -value >= huge then
+      -- This is the behaviour of the original JSON implementation.
+      s = "null"
+    else
+      s = num2str (value)
+    end
+    buflen = buflen + 1
+    buffer[buflen] = s
+  elseif valtype == 'boolean' then
+    buflen = buflen + 1
+    buffer[buflen] = value and "true" or "false"
+  elseif valtype == 'string' then
+    buflen = buflen + 1
+    buffer[buflen] = quotestring (value)
+  elseif valtype == 'table' then
+    if tables[value] then
+      return exception('reference cycle', value, state, buffer, buflen)
+    end
+    tables[value] = true
+    level = level + 1
+    local isa, n = isarray (value)
+    if n == 0 and valmeta and valmeta.__jsontype == 'object' then
+      isa = false
+    end
+    local msg
+    if isa then -- JSON array
+      buflen = buflen + 1
+      buffer[buflen] = "["
+      for i = 1, n do
+        buflen, msg = encode2 (value[i], indent, level, buffer, buflen, tables, globalorder, state)
+        if not buflen then return nil, msg end
+        if i < n then
+          buflen = buflen + 1
+          buffer[buflen] = ","
+        end
+      end
+      buflen = buflen + 1
+      buffer[buflen] = "]"
+    else -- JSON object
+      local prev = false
+      buflen = buflen + 1
+      buffer[buflen] = "{"
+      local order = valmeta and valmeta.__jsonorder or globalorder
+      if order then
+        local used = {}
+        n = #order
+        for i = 1, n do
+          local k = order[i]
+          local v = value[k]
+          if v ~= nil then
+            used[k] = true
+            buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
+            if not buflen then return nil, msg end
+            prev = true -- add a seperator before the next element
+          end
+        end
+        for k,v in pairs (value) do
+          if not used[k] then
+            buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
+            if not buflen then return nil, msg end
+            prev = true -- add a seperator before the next element
+          end
+        end
+      else -- unordered
+        for k,v in pairs (value) do
+          buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state)
+          if not buflen then return nil, msg end
+          prev = true -- add a seperator before the next element
+        end
+      end
+      if indent then
+        buflen = addnewline2 (level - 1, buffer, buflen)
+      end
+      buflen = buflen + 1
+      buffer[buflen] = "}"
+    end
+    tables[value] = nil
+  else
+    return exception ('unsupported type', value, state, buffer, buflen,
+      "type '" .. valtype .. "' is not supported by JSON.")
+  end
+  return buflen
+end
+
+function json.encode (value, state)
+  state = state or {}
+  local oldbuffer = state.buffer
+  local buffer = oldbuffer or {}
+  state.buffer = buffer
+  updatedecpoint()
+  local ret, msg = encode2 (value, state.indent, state.level or 0,
+                   buffer, state.bufferlen or 0, state.tables or {}, state.keyorder, state)
+  if not ret then
+    error (msg, 2)
+  elseif oldbuffer == buffer then
+    state.bufferlen = ret
+    return true
+  else
+    state.bufferlen = nil
+    state.buffer = nil
+    return concat (buffer)
+  end
+end
+
+local function loc (str, where)
+  local line, pos, linepos = 1, 1, 0
+  while true do
+    pos = strfind (str, "\n", pos, true)
+    if pos and pos < where then
+      line = line + 1
+      linepos = pos
+      pos = pos + 1
+    else
+      break
+    end
+  end
+  return strformat ("line %d, column %d", line, where - linepos)
+end
+
+local function unterminated (str, what, where)
+  return nil, strlen (str) + 1, "unterminated " .. what .. " at " .. loc (str, where)
+end
+
+local function scanwhite (str, pos)
+  while true do
+    pos = strfind (str, "%S", pos)
+    if not pos then return nil end
+    local sub2 = strsub (str, pos, pos + 1)
+    if sub2 == "\239\187" and strsub (str, pos + 2, pos + 2) == "\191" then
+      -- UTF-8 Byte Order Mark
+      pos = pos + 3
+    elseif sub2 == "//" then
+      pos = strfind (str, "[\n\r]", pos + 2)
+      if not pos then return nil end
+    elseif sub2 == "/*" then
+      pos = strfind (str, "*/", pos + 2)
+      if not pos then return nil end
+      pos = pos + 2
+    else
+      return pos
+    end
+  end
+end
+
+local escapechars = {
+  ["\""] = "\"", ["\\"] = "\\", ["/"] = "/", ["b"] = "\b", ["f"] = "\f",
+  ["n"] = "\n", ["r"] = "\r", ["t"] = "\t"
+}
+
+local function unichar (value)
+  if value < 0 then
+    return nil
+  elseif value <= 0x007f then
+    return strchar (value)
+  elseif value <= 0x07ff then
+    return strchar (0xc0 + floor(value/0x40),
+                    0x80 + (floor(value) % 0x40))
+  elseif value <= 0xffff then
+    return strchar (0xe0 + floor(value/0x1000),
+                    0x80 + (floor(value/0x40) % 0x40),
+                    0x80 + (floor(value) % 0x40))
+  elseif value <= 0x10ffff then
+    return strchar (0xf0 + floor(value/0x40000),
+                    0x80 + (floor(value/0x1000) % 0x40),
+                    0x80 + (floor(value/0x40) % 0x40),
+                    0x80 + (floor(value) % 0x40))
+  else
+    return nil
+  end
+end
+
+local function scanstring (str, pos)
+  local lastpos = pos + 1
+  local buffer, n = {}, 0
+  while true do
+    local nextpos = strfind (str, "[\"\\]", lastpos)
+    if not nextpos then
+      return unterminated (str, "string", pos)
+    end
+    if nextpos > lastpos then
+      n = n + 1
+      buffer[n] = strsub (str, lastpos, nextpos - 1)
+    end
+    if strsub (str, nextpos, nextpos) == "\"" then
+      lastpos = nextpos + 1
+      break
+    else
+      local escchar = strsub (str, nextpos + 1, nextpos + 1)
+      local value
+      if escchar == "u" then
+        value = tonumber (strsub (str, nextpos + 2, nextpos + 5), 16)
+        if value then
+          local value2
+          if 0xD800 <= value and value <= 0xDBff then
+            -- we have the high surrogate of UTF-16. Check if there is a
+            -- low surrogate escaped nearby to combine them.
+            if strsub (str, nextpos + 6, nextpos + 7) == "\\u" then
+              value2 = tonumber (strsub (str, nextpos + 8, nextpos + 11), 16)
+              if value2 and 0xDC00 <= value2 and value2 <= 0xDFFF then
+                value = (value - 0xD800)  * 0x400 + (value2 - 0xDC00) + 0x10000
+              else
+                value2 = nil -- in case it was out of range for a low surrogate
+              end
+            end
+          end
+          value = value and unichar (value)
+          if value then
+            if value2 then
+              lastpos = nextpos + 12
+            else
+              lastpos = nextpos + 6
+            end
+          end
+        end
+      end
+      if not value then
+        value = escapechars[escchar] or escchar
+        lastpos = nextpos + 2
+      end
+      n = n + 1
+      buffer[n] = value
+    end
+  end
+  if n == 1 then
+    return buffer[1], lastpos
+  elseif n > 1 then
+    return concat (buffer), lastpos
+  else
+    return "", lastpos
+  end
+end
+
+local scanvalue -- forward declaration
+
+local function scantable (what, closechar, str, startpos, nullval, objectmeta, arraymeta)
+  local tbl, n = {}, 0
+  local pos = startpos + 1
+  if what == 'object' then
+    setmetatable (tbl, objectmeta)
+  else
+    setmetatable (tbl, arraymeta)
+  end
+  while true do
+    pos = scanwhite (str, pos)
+    if not pos then return unterminated (str, what, startpos) end
+    local char = strsub (str, pos, pos)
+    if char == closechar then
+      return tbl, pos + 1
+    end
+    local val1, err
+    val1, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta)
+    if err then return nil, pos, err end
+    pos = scanwhite (str, pos)
+    if not pos then return unterminated (str, what, startpos) end
+    char = strsub (str, pos, pos)
+    if char == ":" then
+      if val1 == nil then
+        return nil, pos, "cannot use nil as table index (at " .. loc (str, pos) .. ")"
+      end
+      pos = scanwhite (str, pos + 1)
+      if not pos then return unterminated (str, what, startpos) end
+      local val2
+      val2, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta)
+      if err then return nil, pos, err end
+      tbl[val1] = val2
+      pos = scanwhite (str, pos)
+      if not pos then return unterminated (str, what, startpos) end
+      char = strsub (str, pos, pos)
+    else
+      n = n + 1
+      tbl[n] = val1
+    end
+    if char == "," then
+      pos = pos + 1
+    end
+  end
+end
+
+scanvalue = function (str, pos, nullval, objectmeta, arraymeta)
+  pos = pos or 1
+  pos = scanwhite (str, pos)
+  if not pos then
+    return nil, strlen (str) + 1, "no valid JSON value (reached the end)"
+  end
+  local char = strsub (str, pos, pos)
+  if char == "{" then
+    return scantable ('object', "}", str, pos, nullval, objectmeta, arraymeta)
+  elseif char == "[" then
+    return scantable ('array', "]", str, pos, nullval, objectmeta, arraymeta)
+  elseif char == "\"" then
+    return scanstring (str, pos)
+  else
+    local pstart, pend = strfind (str, "^%-?[%d%.]+[eE]?[%+%-]?%d*", pos)
+    if pstart then
+      local number = str2num (strsub (str, pstart, pend))
+      if number then
+        return number, pend + 1
+      end
+    end
+    pstart, pend = strfind (str, "^%a%w*", pos)
+    if pstart then
+      local name = strsub (str, pstart, pend)
+      if name == "true" then
+        return true, pend + 1
+      elseif name == "false" then
+        return false, pend + 1
+      elseif name == "null" then
+        return nullval, pend + 1
+      end
+    end
+    return nil, pos, "no valid JSON value at " .. loc (str, pos)
+  end
+end
+
+local function optionalmetatables(...)
+  if select("#", ...) > 0 then
+    return ...
+  else
+    return {__jsontype = 'object'}, {__jsontype = 'array'}
+  end
+end
+
+function json.decode (str, pos, nullval, ...)
+  local objectmeta, arraymeta = optionalmetatables(...)
+  return scanvalue (str, pos, nullval, objectmeta, arraymeta)
+end
+
+function json.use_lpeg ()
+  local g = require ("lpeg")
+
+  if type(g.version) == 'function' and g.version() == "0.11" then
+    error "due to a bug in LPeg 0.11, it cannot be used for JSON matching"
+  end
+
+  local pegmatch = g.match
+  local P, S, R = g.P, g.S, g.R
+
+  local function ErrorCall (str, pos, msg, state)
+    if not state.msg then
+      state.msg = msg .. " at " .. loc (str, pos)
+      state.pos = pos
+    end
+    return false
+  end
+
+  local function Err (msg)
+    return g.Cmt (g.Cc (msg) * g.Carg (2), ErrorCall)
+  end
+
+  local function ErrorUnterminatedCall (str, pos, what, state)
+    return ErrorCall (str, pos - 1, "unterminated " .. what, state)
+  end
+
+  local SingleLineComment = P"//" * (1 - S"\n\r")^0
+  local MultiLineComment = P"/*" * (1 - P"*/")^0 * P"*/"
+  local Space = (S" \n\r\t" + P"\239\187\191" + SingleLineComment + MultiLineComment)^0
+
+  local function ErrUnterminated (what)
+    return g.Cmt (g.Cc (what) * g.Carg (2), ErrorUnterminatedCall)
+  end
+
+  local PlainChar = 1 - S"\"\\\n\r"
+  local EscapeSequence = (P"\\" * g.C (S"\"\\/bfnrt" + Err "unsupported escape sequence")) / escapechars
+  local HexDigit = R("09", "af", "AF")
+  local function UTF16Surrogate (match, pos, high, low)
+    high, low = tonumber (high, 16), tonumber (low, 16)
+    if 0xD800 <= high and high <= 0xDBff and 0xDC00 <= low and low <= 0xDFFF then
+      return true, unichar ((high - 0xD800)  * 0x400 + (low - 0xDC00) + 0x10000)
+    else
+      return false
+    end
+  end
+  local function UTF16BMP (hex)
+    return unichar (tonumber (hex, 16))
+  end
+  local U16Sequence = (P"\\u" * g.C (HexDigit * HexDigit * HexDigit * HexDigit))
+  local UnicodeEscape = g.Cmt (U16Sequence * U16Sequence, UTF16Surrogate) + U16Sequence/UTF16BMP
+  local Char = UnicodeEscape + EscapeSequence + PlainChar
+  local String = P"\"" * (g.Cs (Char ^ 0) * P"\"" + ErrUnterminated "string")
+  local Integer = P"-"^(-1) * (P"0" + (R"19" * R"09"^0))
+  local Fractal = P"." * R"09"^0
+  local Exponent = (S"eE") * (S"+-")^(-1) * R"09"^1
+  local Number = (Integer * Fractal^(-1) * Exponent^(-1))/str2num
+  local Constant = P"true" * g.Cc (true) + P"false" * g.Cc (false) + P"null" * g.Carg (1)
+  local SimpleValue = Number + String + Constant
+  local ArrayContent, ObjectContent
+
+  -- The functions parsearray and parseobject parse only a single value/pair
+  -- at a time and store them directly to avoid hitting the LPeg limits.
+  local function parsearray (str, pos, nullval, state)
+    local obj, cont
+    local start = pos
+    local npos
+    local t, nt = {}, 0
+    repeat
+      obj, cont, npos = pegmatch (ArrayContent, str, pos, nullval, state)
+      if cont == 'end' then
+        return ErrorUnterminatedCall (str, start, "array", state)
+      end
+      pos = npos
+      if cont == 'cont' or cont == 'last' then
+        nt = nt + 1
+        t[nt] = obj
+      end
+    until cont ~= 'cont'
+    return pos, setmetatable (t, state.arraymeta)
+  end
+
+  local function parseobject (str, pos, nullval, state)
+    local obj, key, cont
+    local start = pos
+    local npos
+    local t = {}
+    repeat
+      key, obj, cont, npos = pegmatch (ObjectContent, str, pos, nullval, state)
+      if cont == 'end' then
+        return ErrorUnterminatedCall (str, start, "object", state)
+      end
+      pos = npos
+      if cont == 'cont' or cont == 'last' then
+        t[key] = obj
+      end
+    until cont ~= 'cont'
+    return pos, setmetatable (t, state.objectmeta)
+  end
+
+  local Array = P"[" * g.Cmt (g.Carg(1) * g.Carg(2), parsearray)
+  local Object = P"{" * g.Cmt (g.Carg(1) * g.Carg(2), parseobject)
+  local Value = Space * (Array + Object + SimpleValue)
+  local ExpectedValue = Value + Space * Err "value expected"
+  local ExpectedKey = String + Err "key expected"
+  local End = P(-1) * g.Cc'end'
+  local ErrInvalid = Err "invalid JSON"
+  ArrayContent = (Value * Space * (P"," * g.Cc'cont' + P"]" * g.Cc'last'+ End + ErrInvalid)  + g.Cc(nil) * (P"]" * g.Cc'empty' + End  + ErrInvalid)) * g.Cp()
+  local Pair = g.Cg (Space * ExpectedKey * Space * (P":" + Err "colon expected") * ExpectedValue)
+  ObjectContent = (g.Cc(nil) * g.Cc(nil) * P"}" * g.Cc'empty' + End + (Pair * Space * (P"," * g.Cc'cont' + P"}" * g.Cc'last' + End + ErrInvalid) + ErrInvalid)) * g.Cp()
+  local DecodeValue = ExpectedValue * g.Cp ()
+
+  jsonlpeg.version = json.version
+  jsonlpeg.encode = json.encode
+  jsonlpeg.null = json.null
+  jsonlpeg.quotestring = json.quotestring
+  jsonlpeg.addnewline = json.addnewline
+  jsonlpeg.encodeexception = json.encodeexception
+  jsonlpeg.using_lpeg = true
+
+  function jsonlpeg.decode (str, pos, nullval, ...)
+    local state = {}
+    state.objectmeta, state.arraymeta = optionalmetatables(...)
+    local obj, retpos = pegmatch (DecodeValue, str, pos, nullval, state)
+    if state.msg then
+      return nil, state.pos, state.msg
+    else
+      return obj, retpos
+    end
+  end
+
+  -- cache result of this function:
+  json.use_lpeg = function () return jsonlpeg end
+  jsonlpeg.use_lpeg = json.use_lpeg
+
+  return jsonlpeg
+end
+
+if always_use_lpeg then
+  return json.use_lpeg()
+end
+
+return json
+

core/middleware.lua

@@ -1,169 +0,0 @@
-local M = {}
-
-function M.json_decode(json)
-    if type(json) ~= "string" then
-        return nil, "input must be a string"
-    end
-
-    local pos = 1
-    local len = #json
-
-    local function skip_ws()
-        while pos <= len and json:sub(pos,pos):match("%s") do
-            pos = pos + 1
-        end
-    end
-
-    local function parse_value()
-        skip_ws()
-        local c = json:sub(pos,pos)
-        if c == "{" then return parse_object()
-        elseif c == "[" then return parse_array()
-        elseif c == '"' then return parse_string()
-        elseif c:match("[%d%-]") then return parse_number()
-        elseif json:sub(pos,pos+3) == "true" then pos=pos+4; return true
-        elseif json:sub(pos,pos+4) == "false" then pos=pos+5; return false
-        elseif json:sub(pos,pos+3) == "null" then pos=pos+4; return nil
-        else return nil, "invalid value at position "..pos
-        end
-    end
-
-    function parse_string()
-        pos = pos + 1
-        local start_pos = pos
-        local str = ""
-        while pos <= len do
-            local c = json:sub(pos,pos)
-            if c == '"' then
-                str = str .. json:sub(start_pos,pos-1)
-                pos = pos + 1
-                return str
-            elseif c == "\\" then
-                str = str .. json:sub(start_pos,pos-1)
-                pos = pos + 1
-                local esc = json:sub(pos,pos)
-                local map = {b="\b", f="\f", n="\n", r="\r", t="\t", ['"']='"', ["\\"]="\\", ["/"]="/"}
-                str = str .. (map[esc] or esc)
-                pos = pos + 1
-                start_pos = pos
-            else
-                pos = pos + 1
-            end
-        end
-        return nil, "unterminated string"
-    end
-
-    function parse_number()
-        local start_pos = pos
-        while pos <= len and json:sub(pos,pos):match("[%d%+%-eE%.]") do
-            pos = pos + 1
-        end
-        local n = tonumber(json:sub(start_pos,pos-1))
-        if not n then return nil, "invalid number at position "..start_pos end
-        return n
-    end
-
-    function parse_array()
-        pos = pos + 1
-        local arr = {}
-        skip_ws()
-        if json:sub(pos,pos) == "]" then pos=pos+1; return arr end
-        while true do
-            local val, err = parse_value()
-            if err then return nil, err end
-            table.insert(arr,val)
-            skip_ws()
-            local c = json:sub(pos,pos)
-            if c == "]" then pos=pos+1; break
-            elseif c == "," then pos=pos+1
-            else return nil, "expected ',' or ']' at position "..pos
-            end
-        end
-        return arr
-    end
-
-    function parse_object()
-        pos = pos + 1
-        local obj = {}
-        skip_ws()
-        if json:sub(pos,pos) == "}" then pos=pos+1; return obj end
-        while true do
-            skip_ws()
-            if json:sub(pos,pos) ~= '"' then return nil, "expected string key at "..pos end
-            local key, err = parse_string()
-            if err then return nil, err end
-            skip_ws()
-            if json:sub(pos,pos) ~= ":" then return nil, "expected ':' at "..pos end
-            pos = pos + 1
-            local val, err = parse_value()
-            if err then return nil, err end
-            obj[key] = val
-            skip_ws()
-            local c = json:sub(pos,pos)
-            if c == "}" then pos=pos+1; break
-            elseif c == "," then pos=pos+1
-            else return nil, "expected ',' or '}' at "..pos
-            end
-        end
-        return obj
-    end
-
-    local result, err = parse_value()
-    if err then return nil, err end
-    skip_ws()
-    if pos <= len then return nil, "trailing characters at "..pos end
-    return result
-end
-
-function M.json_encode(value)
-    local t = type(value)
-    if t == "nil" then
-        return "null"
-    elseif t == "boolean" then
-        return tostring(value)
-    elseif t == "number" then
-        return tostring(value)
-    elseif t == "string" then
-        return '"' .. value:gsub('[%z\1-\31\\"]', {
-            ['\\'] = '\\\\',
-            ['"'] = '\\"',
-            ['\b'] = '\\b',
-            ['\f'] = '\\f',
-            ['\n'] = '\\n',
-            ['\r'] = '\\r',
-            ['\t'] = '\\t'
-        }):gsub("[%z\1-\31]", function(c)
-            return string.format("\\u%04x", c:byte())
-        end) .. '"'
-    elseif t == "table" then
-        local is_array = true
-        local max_index = 0
-        for k,v in pairs(value) do
-            if type(k) ~= "number" then
-                is_array = false
-            else
-                if k > max_index then max_index = k end
-            end
-        end
-
-        local items = {}
-        if is_array then
-            for i = 1, max_index do
-                table.insert(items, M.json_encode(value[i]))
-            end
-            return "[" .. table.concat(items,",") .. "]"
-        else
-            for k,v in pairs(value) do
-                if type(k) ~= "string" then
-                    return nil, "object keys must be strings"
-                end
-                table.insert(items, M.json_encode(k) .. ":" .. M.json_encode(v))
-            end
-            return "{" .. table.concat(items,",") .. "}"
-        end
-    else
-        return nil, "unsupported type: " .. t
-    end
-end
-
-return M

core/std.lua

@@ -186,46 +186,6 @@ function M.site_authors()
 	return {}
 end
 
--- Join array with separator
-function M.join(arr, sep)
-	arr = arr or {}
-	sep = sep or ", "
-	local result = {}
-	for _, v in ipairs(arr) do
-		table.insert(result, tostring(v))
-	end
-	return table.concat(result, sep)
-end
-
--- Trim whitespace
-function M.trim(str)
-	str = tostring(str or "")
-	return str:match("^%s*(.-)%s*$")
-end
-
--- Table HTML generator
-function M.table(headers, rows)
-	headers = headers or {}
-	rows = rows or {}
-
-	local html = "<table><thead><tr>"
-	for _, header in ipairs(headers) do
-		html = html .. "<th>" .. tostring(header) .. "</th>"
-	end
-	html = html .. "</tr></thead><tbody>"
-
-	for _, row in ipairs(rows) do
-		html = html .. "<tr>"
-		for _, cell in ipairs(row) do
-			html = html .. "<td>" .. tostring(cell) .. "</td>"
-		end
-		html = html .. "</tr>"
-	end
-
-	html = html .. "</tbody></table>"
-	return html
-end
-
 function M.highlight(str)
 	return '<span class="highlight">' .. (str or "") .. "</span>"
 end

index.html

@@ -0,0 +1,500 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<title>Documentation</title>
+	<style>
+html, body {
+	min-height: 100%;
+	margin: 0;
+	padding: 0;
+	background: #0f1113;
+	color: #e6eef3;
+	font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+	line-height: 1.5;
+	-webkit-font-smoothing: antialiased;
+	-moz-osx-font-smoothing: grayscale;
+}
+
+main {
+	max-width: 830px;
+	margin: 0 auto;
+	padding: 36px;
+}
+
+header {
+	margin-bottom: 36px;
+}
+
+h1 {
+	font-size: 40px;
+	font-weight: 700;
+	margin: 0 0 20px 0;
+}
+
+h2 {
+	font-size: 32px;
+	margin: 26px 0 14px;
+	border-bottom: 1px solid rgba(255,255,255,.1);
+	padding-bottom: 6px;
+}
+
+h3 {
+	font-size: 26px;
+	margin: 22px 0 12px;
+}
+
+p {
+	margin: 14px 0;
+}
+
+header p {
+	color: #9aa6b1;
+}
+
+nav {
+	margin: 28px 0;
+	padding: 20px;
+	background: #1a1c20;
+	border: 1px solid rgba(255,255,255,.06);
+	border-radius: 4px;
+}
+
+nav h2 {
+	font-size: 20px;
+	margin: 0 0 12px 0;
+	border: none;
+	padding: 0;
+}
+
+nav ul {
+	list-style: none;
+	padding: 0;
+	margin: 0;
+}
+
+nav li {
+	margin: 6px 0;
+}
+
+a {
+	color: #68a6ff;
+	text-decoration: none;
+	transition: color .15s ease;
+}
+
+a:hover {
+	text-decoration: underline;
+}
+
+section {
+	margin-top: 36px;
+}
+
+ul, ol {
+	margin: 14px 0;
+	padding-left: 26px;
+}
+
+li {
+	margin: 6px 0;
+}
+
+code {
+	padding: 3px 7px;
+	border-radius: 3px;
+	font-family: "SF Mono", Monaco, "Cascadia Code", "Roboto Mono", Consolas, "Courier New", monospace;
+	font-size: .9em;
+	color: #cde7ff;
+	background: #1a1c20;
+	border: 1px solid rgba(255,255,255,.06);
+}
+
+pre {
+	padding: 20px;
+	border-radius: 4px;
+	margin: 14px 0;
+	overflow-x: auto;
+	background: #1a1c20;
+	border: 1px solid rgba(255,255,255,.06);
+	font-family: "SF Mono", Monaco, "Cascadia Code", "Roboto Mono", Consolas, "Courier New", monospace;
+	font-size: 14px;
+	line-height: 1.6;
+}
+
+pre code {
+	background: none;
+	border: none;
+	padding: 0;
+	font-size: inherit;
+	color: inherit;
+}
+
+blockquote {
+	border-left: 3px solid #68a6ff;
+	padding-left: 18px;
+	margin: 14px 0;
+	color: #dfe9ee;
+	font-style: italic;
+}
+
+table {
+	width: 100%;
+	border-collapse: collapse;
+	margin: 14px 0;
+}
+
+th, td {
+	padding: 12px 16px;
+	text-align: left;
+	border-bottom: 1px solid rgba(255,255,255,.06);
+}
+
+th {
+	background: #1a1c20;
+	font-weight: 600;
+	color: #f0f6f8;
+}
+
+tr:hover {
+	background: rgba(255,255,255,.02);
+}
+
+footer {
+	margin-top: 48px;
+	padding-top: 20px;
+	border-top: 1px solid rgba(255,255,255,.1);
+	color: #9aa6b1;
+	font-size: 14px;
+}
+	</style>
+</head>
+<body>
+	<main>
+		<header>
+			<h1>Documentation</h1>
+			<p>Fes: A lightweight, static, and opinionated microframework.</p>
+		</header>
+
+		<nav>
+			<h2>Contents</h2>
+			<ul>
+				<li><a href="#introduction">Introduction</a></li>
+				<li><a href="#installation">Installation</a></li>
+				<li><a href="#usage">Usage</a></li>
+				<li><a href="#cli-reference">Cli Reference</a></li>
+				<li><a href="#reference">Reference</a></li>
+			</ul>
+		</nav>
+
+		<section id="introduction">
+			<h2>Introduction</h2>
+			<p>Fes, or Free Easy Site, is a microframework used for small static sites. It is not designed for complex web applications and that is why it is good. Yes, I hate modern web and that is the reason this exists.</p>
+		</section>
+
+		<section id="installation">
+			<h2>Installation</h2>
+			<pre><code>git clone https://git.vxserver.dev/fSD/fes</code></pre>
+			<pre><code>cd fes</code></pre>
+			<pre><code>go install fes</code></pre>
+		</section>
+
+		<section id="usage">
+			<h2>Usage</h2>
+			<p>Typical workflows and examples.</p>
+			<ul>
+				<li>Creating project</li>
+				<li>Hosting websites</li>
+				<li>Generating websites</li>
+			</ul>
+		</section>
+
+		<section id="cli-reference">
+			<h2>Cli Reference</h2>
+			<table> <thead>
+					<tr>
+						<th>Name</th>
+						<th>Description</th>
+					</tr>
+				</thead>
+				<tbody>
+					<tr>
+						<td><code>--help</code></td>
+						<td>Display help information</td>
+					</tr>
+					<tr>
+						<td><code>--no-color</code></td>
+						<td>Disable color output</td>
+					</tr>
+					<tr>
+						<td><code>-p &lt;port&gt;</code></td>
+						<td>Set the server port</td>
+					</tr>
+					<tr>
+						<td><code>new &lt;project&gt;</code></td>
+						<td>Create a new projet called &lt;project&gt;</td>
+					</tr>
+					<tr>
+						<td><code>doc</code></td>
+						<td>Open this documention page</td>
+					</tr>
+					<tr>
+						<td><code>run &lt;project&gt;</code></td>
+						<td>Run the projet called &lt;project&gt;</td>
+					</tr>
+				</tbody>
+			</table>
+		</section>
+
+		<section id="reference">
+			<h2>Reference</h2>
+			All <code>std</code> functions have binding for the site and can be used like so: <code>site:h1("Hello, World!")</code>, where site is the site object.
+			<h3>Builtin</h3>
+			<table>
+				<thead>
+					<tr>
+						<th>Name</th>
+						<th>Description</th>
+					</tr>
+				</thead>
+				<tbody>
+					<tr>
+						<td><code>fes()</code></td>
+						<td>Generate a site object</td>
+					</tr>
+					<tr>
+						<td><code>:custom()</code></td>
+						<td>Add a custom string to the site body</td>
+					</tr>
+				</tbody>
+			</table>
+			<h3>Std</h3>
+			<table>
+				<thead>
+					<tr>
+						<th>Name</th>
+						<th>Description</th>
+					</tr>
+				</thead>
+				<tbody>
+					<tr>
+						<td><code>std.fes_version()</code></td>
+						<td>Get the current version of fes.</td>
+					</tr>
+					<tr>
+						<td><code>std.site_version()</code></td>
+						<td>Get the current version of the site, defined in <code>Fes.toml</code>.</td>
+					</tr>
+					<tr>
+						<td><code>std.site_name()</code></td>
+						<td>Get the current name of the site, defined in <code>Fes.toml</code>.</td>
+					</tr>
+					<tr>
+						<td><code>std.site_title()</code></td>
+						<td>Get the current name of the site, defined in <code>Fes.toml</code>.</td>
+					</tr>
+					<tr>
+						<td><code>std.site_authors()</code></td>
+						<td>Get a table of the authors of the site, defined in <code>Fes.toml</code>.</td>
+					</tr>
+					<tr>
+						<td><code>std.join</code></td>
+						<td>Get a table of the authors of the site, defined in <code>Fes.toml</code>.</td>
+					</tr>
+					<tr>
+						<td><code>std.a(link: string, str: string)</code></td>
+						<td>Returns an anchor tag.</td>
+					</tr>
+					<tr>
+						<td><code>std.ha(link: string, str: string)</code></td>
+						<td>Returns an anchor tag with sytiling to make it hidden.</td>
+					</tr>
+					<tr>
+						<td><code>std.external(link: string, str: string)</code></td>
+						<td>Returns an anchor tag that opens up in a new tab.</td>
+					</tr>
+					<tr>
+						<td><code>std.note(str: string)</code></td>
+						<td>Returns a note object.</td>
+					</tr>
+					<tr>
+						<td><code>std.muted(str: string)</code></td>
+						<td>Returns a muted object.</td>
+					</tr>
+					<tr>
+						<td><code>std.callout(str: string)</code></td>
+						<td>Returns a callout object.</td>
+					</tr>
+					<tr>
+						<td><code>std.h1(str: string)</code></td>
+						<td>Returns a header level 1 object.</td>
+					</tr>
+					<tr>
+						<td><code>std.h2(str: string)</code></td>
+						<td>Returns a header level 2 object.</td>
+					</tr>
+					<tr>
+						<td><code>std.h3(str: string)</code></td>
+						<td>Returns a header level 3 object.</td>
+					</tr>
+					<tr>
+						<td><code>std.h4(str: string)</code></td>
+						<td>Returns a header level 4 object.</td>
+					</tr>
+					<tr>
+						<td><code>std.h5(str: string)</code></td>
+						<td>Returns a header level 5 object.</td>
+					</tr>
+					<tr>
+						<td><code>std.h6(str: string)</code></td>
+						<td>Returns a header level 6 object.</td>
+					</tr>
+					<tr>
+						<td><code>std.p(str: string)</code></td>
+						<td>Returns a paragraph object.</td>
+					</tr>
+					<tr>
+						<td><code>std.pre(str: string)</code></td>
+						<td>Returns preformated text.</td>
+					</tr>
+					<tr>
+						<td><code>std.code(str: string)</code></td>
+						<td>Returns a codeblock.</td>
+					</tr>
+					<tr>
+						<td><code>std.ul(items: {...strings})</code></td>
+						<td>Generates an unordered list from a table of strings.</td>
+					</tr>
+					<tr>
+						<td><code>std.ol(items: {...strings})</code></td>
+						<td>Generates an ordered list from a table of strings.</td>
+					</tr>
+					<tr>
+						<td><code>std.tl(items: {...strings})</code></td>
+						<td>Generates a table from a table of strings.</td>
+					</tr>
+					<tr>
+						<td><code>std.blockquote(str: string)</code></td>
+						<td>Returns a blockquote.</td>
+					</tr>
+					<tr>
+						<td><code>std.hr()</code></td>
+						<td>Returns a horizonal rule.</td>
+					</tr>
+					<tr>
+						<td><code>std.img(src: string, alt: string)</code></td>
+						<td>Returns an image at location source with given alternative text.</td>
+					</tr>
+					<tr>
+						<td><code>std.strong(str: string)</code></td>
+						<td>Returns bolded text.</td>
+					</tr>
+					<tr>
+						<td><code>std.em(str: string)</code></td>
+						<td>Returns italicized text.</td>
+					</tr>
+					<tr>
+						<td><code>std.br()</code></td>
+						<td>Returns a break.</td>
+					</tr>
+					<tr>
+						<td><code>std.div(content: string, class: string)</code></td>
+						<td>Returns a div of class <code>class</code> with content of <code>content</code>.</td>
+					</tr>
+					<tr>
+						<td><code>std.spa(content: string, class: string)</code></td>
+						<td>Returns a span of class <code>class</code> with content of <code>content</code>.</td>
+					</tr>
+					<tr>
+						<td><code>std.escape(str: string)</code></td>
+						<td>Returns an html escaped string.</td>
+					</tr>
+					<tr>
+						<td><code>std.highlight(str: string)</code></td>
+						<td>Returns highlighted text.</td>
+					</tr>
+					<tr>
+						<td><code>std.banner(str: string)</code></td>
+						<td>Returns a banner that is attached to the top of the site.</td>
+					</tr>
+					<tr>
+						<td><code>std.center(str: string)</code></td>
+						<td>Returns centered text.</td>
+					</tr>
+					<tr>
+						<td><code>std.nav(link: string, str: string)</code></td>
+						<td>Returns a speical navigation link, used for in-site traversal.</td>
+					</tr>
+					<tr>
+						<td><code>std.rl(r: string, l: string)</code></td>
+						<td>Right and light alight content.</td>
+					</tr>
+				</tbody>
+			</table>
+			<h3>Symbol</h3>
+			<table> <thead>
+					<tr>
+						<th>Name</th>
+						<th>Symbol</th>
+					</tr>
+				</thead>
+				<tbody>
+					<tr>
+						<td><code>symbol.copyright</code></td>
+						<td>&#169;</td> </tr>
+					<tr>
+						<td><code>Registered Trademark</code></td>
+						<td>&#174;</td>
+					</tr>
+					<tr>
+						<td><code>Trademark</code></td>
+						<td>&#8482;</td>
+					</tr>
+				</tbody>
+			</table>
+			<h3>Util</h3>
+			<table> <thead>
+					<tr>
+						<th>Name</th>
+						<th>Description</th>
+					</tr>
+				</thead>
+				<tbody>
+					<tr>
+						<td><code>util.cc(tbl: {...strings})</code></td>
+						<td>Concatenate a table of strings into a single string.</td>
+					</tr>
+					<tr>
+						<td><code>util.copyright(link: string, holder: string)</code></td>
+						<td>Used when setting the website copyright holder.</td>
+					</tr>
+				</tbody>
+			</table>
+			<h3>Dkjson</h3>
+			This is a third party object and is best documented <a href="https://dkolf.de/dkjson-lua/documentation" target="_blank">here</a>
+			<table> <thead>
+					<tr>
+						<th>Name</th>
+						<th>Description</th>
+					</tr>
+				</thead>
+				<tbody>
+					<tr>
+						<td><code>dkjson.encode(obj: {...any})</code></td>
+						<td>Serilize a Lua table into JSON.</td>
+					</tr>
+					<tr>
+						<td><code>dkjson.decode(obj: {...any})</code></td>
+						<td>Deserilize JSON into a Lua table.</td>
+					</tr>
+				</tbody>
+			</table>
+		</section>
+
+		<footer>
+			<p>Last updated: 2025-12-14</p>
+		</footer>
+	</main>
+</body>
+</html>

main.go

@@ -18,10 +18,14 @@ import (
 //go:embed core/*
 var core embed.FS
 
+//go:embed index.html
+var documentation string
+
 func init() {
 	config.Port = flag.Int("p", 3000, "Set the server port")
 	config.Color = flag.Bool("no-color", false, "Disable color output")
 	config.Core = core
+	config.Doc = documentation
 }
 
 func main() {

src/config/config.go

@@ -1,8 +1,12 @@
 package config
 
-import "embed"
+import (
+	"embed"
+	"errors"
+)
 
 var Core embed.FS
+var Doc string
 var Port *int
 var Color *bool
 
@@ -13,3 +17,5 @@ type MyConfig struct {
 		Authors []string `toml:"authors"`
 	} `toml:"app"`
 }
+
+var ErrRouteMiss = errors.New("not found")

src/doc/doc.go

@@ -1,6 +1,7 @@
 package doc
 
 import (
+	"fes/src/config"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -12,12 +13,8 @@ func Open() error {
 	fmt.Println("Opening documentation in browser")
 
 	tmpFile := filepath.Join(os.TempDir(), "doc.html")
-	content := `<html><body><pre>
-This feature is not implemented yet. It will be once the doc site
-is up and running, for now read through the core/ files and examples.
-</pre></body></html>`
 
-	if err := os.WriteFile(tmpFile, []byte(content), 0644); err != nil {
+	if err := os.WriteFile(tmpFile, []byte(config.Doc), 0644); err != nil {
 		return err
 	}
 

src/server/server.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"fmt"
+	"html/template"
 	"io/fs"
 	"net/http"
 	"os"
@@ -13,13 +14,13 @@ import (
 	"time"
 
 	"fes/src/config"
-	"github.com/fatih/color"
+	"fes/src/ui"
+
 	"github.com/gomarkdown/markdown"
 	"github.com/gomarkdown/markdown/html"
 	"github.com/gomarkdown/markdown/parser"
 	"github.com/pelletier/go-toml/v2"
 	lua "github.com/yuin/gopher-lua"
-	"html/template"
 )
 
 type reqData struct {
@@ -135,7 +136,7 @@ func loadIncludeModules(L *lua.LState, includeDir string) *lua.LTable {
 	return app
 }
 
-func loadLua(luaDir string, entry string, cfg *config.MyConfig, requestData reqData) (string, error) {
+func loadLua(luaDir string, entry string, cfg *config.MyConfig, requestData reqData) ([]byte, error) {
 	L := lua.NewState()
 	defer L.Close()
 
@@ -238,26 +239,26 @@ func loadLua(luaDir string, entry string, cfg *config.MyConfig, requestData reqD
 	})
 
 	if err := L.DoFile(entry); err != nil {
-		return "", err
+		return []byte(""), err
 	}
 
 	if L.GetTop() == 0 {
-		return "", nil
+		return []byte(""), nil
 	}
 
 	L.SetGlobal("__fes_result", L.Get(-1))
 	if err := L.DoString("return tostring(__fes_result)"); err != nil {
 		L.GetGlobal("__fes_result")
 		if s := L.ToString(-1); s != "" {
-			return s, nil
+			return []byte(s), nil
 		}
-		return "", nil
+		return []byte(""), nil
 	}
 
 	if s := L.ToString(-1); s != "" {
-		return s, nil
+		return []byte(s), nil
 	}
-	return "", nil
+	return []byte(""), nil
 }
 
 func generateArchiveIndex(fsPath string, urlPath string) (string, error) {
@@ -352,24 +353,24 @@ func generateArchiveIndex(fsPath string, urlPath string) (string, error) {
 
 func Start(dir string) error {
 	if err := os.Chdir(dir); err != nil {
-		return fmt.Errorf("failed to change directory to %s: %w", dir, err)
+		return ui.Error(fmt.Sprintf("failed to change directory to %s", dir), err)
 	}
 	dir = "."
 
 	tomlDocument, err := os.ReadFile("Fes.toml")
 	if err != nil {
-		return fmt.Errorf("failed to read Fes.toml: %w", err)
+		return ui.Error("failed to read Fes.toml", err)
 	}
 	docStr := fixMalformedToml(string(tomlDocument))
 	var cfg config.MyConfig
 	if err := toml.Unmarshal([]byte(docStr), &cfg); err != nil {
-		fmt.Printf("Warning: failed to parse Fes.toml: %v\n", err)
+		ui.Warning("failed to parse Fes.toml", err)
 		cfg.App.Authors = []string{"unknown"}
 		cfg.App.Name = "unknown"
 		cfg.App.Version = "unknown"
 	}
 
-	notFoundData := `
+	notFoundData := []byte(`
 <html>
 <head><title>404 Not Found</title></head>
 <body>
@@ -377,93 +378,85 @@ func Start(dir string) error {
 <hr><center>fes</center>
 </body>
 </html>
-`
+`)
 	if _, err := os.Stat(filepath.Join("www", "404.lua")); err == nil {
 		if nf, err := loadLua(dir, "www/404.lua", &cfg, reqData{}); err == nil {
 			notFoundData = nf
 		}
 	} else if _, err := os.Stat("www/404.html"); err == nil {
 		if buf, err := os.ReadFile("www/404.html"); err == nil {
-			notFoundData = string(buf)
+			notFoundData = buf
 		}
 	}
 
 	routes := make(map[string]string)
 	if entries, err := os.ReadDir("www"); err == nil {
 		if err := handleDir(entries, "www", routes, "", false); err != nil {
-			fmt.Printf("Warning: failed to handle www directory: %v\n", err)
+			ui.Warning("failed to handle www directory", err)
 		}
 	}
 
 	if entries, err := os.ReadDir("static"); err == nil {
 		if err := handleDir(entries, "static", routes, "/static", true); err != nil {
-			fmt.Printf("Warning: failed to handle static directory: %v\n", err)
+			ui.Warning("failed to handle static directory", err)
 		}
 	}
 
 	if entries, err := os.ReadDir("archive"); err == nil {
 		if err := handleDir(entries, "archive", routes, "/archive", true); err != nil {
-			fmt.Printf("Warning: failed to handle archive directory: %v\n", err)
+			ui.Warning("failed to handle archive directory", err)
 		}
 	}
 
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		path := r.URL.Path
-		p, ok := routes[path]
-		fmt.Printf("> %s ", basePath(filepath.Base(p)))
+		route, ok := routes[r.URL.Path]
 
-		if !ok && strings.HasPrefix(path, "/archive") {
-			fsPath := "." + path
-			info, err := os.Stat(fsPath)
-			if err == nil && info.IsDir() {
-				if htmlStr, err := generateArchiveIndex(fsPath, path); err == nil {
-					w.Write([]byte(htmlStr))
-					return
-				}
-			}
-		}
+		var err error = nil
+		defer func() {
+			ui.Path(route, err)
+		}()
 
 		if !ok {
-			w.WriteHeader(http.StatusNotFound)
-			w.Write([]byte(notFoundData))
-			color.Yellow("not found")
-			return
+			err = config.ErrRouteMiss
+			route = r.URL.Path
+
+			if strings.HasPrefix(route, "/archive") {
+				fsPath := "." + route
+				if info, err := os.Stat(fsPath); err == nil && info.IsDir() {
+					if page, err := generateArchiveIndex(fsPath, route); err == nil {
+						w.Write([]byte(page))
+						return
+					}
+				}
+			} else {
+				w.WriteHeader(http.StatusNotFound)
+				w.Write([]byte(notFoundData))
+				return
+			}
 		}
 
 		params := make(map[string]string)
-		for k, val := range r.URL.Query() {
-			if len(val) > 0 {
-				params[k] = val[0]
+		for k, v := range r.URL.Query() {
+			if len(v) > 0 {
+				params[k] = v[0]
 			}
 		}
 
-		req := reqData{
-			path:   path,
-			params: params,
-		}
-
 		var data []byte
-		var err error
-
-		if strings.HasSuffix(p, ".lua") {
-			var b string
-			b, err = loadLua(dir, p, &cfg, req)
-			data = []byte(b)
-		} else if strings.HasSuffix(p, ".md") {
-			data, err = os.ReadFile(p)
+		if strings.HasSuffix(route, ".lua") {
+			data, err = loadLua(dir, route, &cfg, reqData{path: r.URL.Path, params: params})
+		} else if strings.HasSuffix(route, ".md") {
+			data, err = os.ReadFile(route)
 			data = []byte(markdownToHTML(string(data)))
 		} else {
-			data, err = os.ReadFile(p)
+			data, err = os.ReadFile(route)
 		}
 
 		if err != nil {
 			http.Error(w, fmt.Sprintf("Error loading page: %v", err), http.StatusInternalServerError)
-			color.Red("bad")
-			return
 		}
 
 		w.Write(data)
-		color.Green("ok")
 	})
 
 	fmt.Printf("Server is running on http://localhost:%d\n", *config.Port)

src/ui/ui.go

@@ -0,0 +1,55 @@
+package ui
+
+import (
+	"errors"
+	"fes/src/config"
+	"fmt"
+	"strings"
+
+	"github.com/fatih/color"
+)
+
+func Path(path string, err error) {
+	path = strings.TrimPrefix(path, "/")
+
+	if path == "" {
+		path = "(null)"
+	}
+
+	fmt.Printf(" > %s ", path)
+	if err == nil {
+		OK("ok")
+		return
+	} else if errors.Is(err, config.ErrRouteMiss) {
+		WARN(config.ErrRouteMiss.Error())
+	} else {
+		ERROR("bad")
+	}
+}
+
+func Warning(msg string, err error) error {
+	fmt.Printf("fes: %s: %v\n", color.MagentaString("warning"), err)
+	return err
+}
+
+func Error(msg string, err error) error {
+	fmt.Printf("fes: %s: %v\n", color.RedString("error"), err)
+	return err
+}
+
+func Fatal(msg string, err error) error {
+	fmt.Printf("fes: %s: %v\n", color.RedString("fatal"), err)
+	panic(err)
+}
+
+func OK(msg string) {
+	color.Green(msg)
+}
+
+func WARN(msg string) {
+	color.Magenta(msg)
+}
+
+func ERROR(msg string) {
+	color.Red(msg)
+}