Module:Wd

-- Original module located at [[:en:Module:Wd]] and [[:en:Module:Wd/i18n]].

require("strict")
local p = {}
local arg = ...
local i18n

local function loadI18n(aliasesP, frame)
 local title

 if frame then
  -- current module invoked by page/template, get its title from frame
  title = frame:getTitle()
 else
  -- current module included by other module, get its title from ...
  title = arg
 end

 if not i18n then
  i18n = require(title .. "/i18n").init(aliasesP)
 end
end

p.claimCommands = {
 property   = "property",
 properties = "properties",
 qualifier  = "qualifier",
 qualifiers = "qualifiers",
 reference  = "reference",
 references = "references"
}

p.generalCommands = {
 label       = "label",
 title       = "title",
 description = "description",
 alias       = "alias",
 aliases     = "aliases",
 badge       = "badge",
 badges      = "badges"
}

p.flags = {
 linked        = "linked",
 short         = "short",
 raw           = "raw",
 multilanguage = "multilanguage",
 unit          = "unit",
 -------------
 preferred     = "preferred",
 normal        = "normal",
 deprecated    = "deprecated",
 best          = "best",
 future        = "future",
 current       = "current",
 former        = "former",
 edit          = "edit",
 editAtEnd     = "edit@end",
 mdy           = "mdy",
 single        = "single",
 sourced       = "sourced"
}

p.args = {
 eid  = "eid",
 page = "page",
 date = "date",
 globalSiteId = "globalSiteId"
}

local aliasesP = {
 coord                   = "P625",
 -----------------------
 image                   = "P18",
 author                  = "P50",
 authorNameString        = "P2093",
 publisher               = "P123",
 importedFrom            = "P143",
 wikimediaImportURL      = "P4656",
 statedIn                = "P248",
 pages                   = "P304",
 language                = "P407",
 hasPart                 = "P527",
 publicationDate         = "P577",
 startTime               = "P580",
 endTime                 = "P582",
 chapter                 = "P792",
 retrieved               = "P813",
 referenceURL            = "P854",
 sectionVerseOrParagraph = "P958",
 archiveURL              = "P1065",
 title                   = "P1476",
 formatterURL            = "P1630",
 quote                   = "P1683",
 shortName               = "P1813",
 definingFormula         = "P2534",
 archiveDate             = "P2960",
 inferredFrom            = "P3452",
 typeOfReference         = "P3865",
 column                  = "P3903",
 subjectNamedAs          = "P1810",
 wikidataProperty        = "P1687",
 publishedIn             = "P1433"
}

local aliasesQ = {
 percentage              = "Q11229",
 prolepticJulianCalendar = "Q1985786",
 citeWeb                 = "Q5637226",
 citeQ                   = "Q22321052"
}

local parameters = {
 property  = "%p",
 qualifier = "%q",
 reference = "%r",
 alias     = "%a",
 badge     = "%b",
 separator = "%s",
 general   = "%x"
}

local formats = {
 property              = "%p[%s][%r]",
 qualifier             = "%q[%s][%r]",
 reference             = "%r",
 propertyWithQualifier = "%p[ <span style=\"font-size:85\\%\">(%q)</span>][%s][%r]",
 alias                 = "%a[%s]",
 badge                 = "%b[%s]"
}

local hookNames = {              -- {level_1, level_2}
 [parameters.property]         = {"getProperty"},
 [parameters.reference]        = {"getReferences", "getReference"},
 [parameters.qualifier]        = {"getAllQualifiers"},
 [parameters.qualifier.."\\d"] = {"getQualifiers", "getQualifier"},
 [parameters.alias]            = {"getAlias"},
 [parameters.badge]            = {"getBadge"}
}

-- default value objects, should NOT be mutated but instead copied
local defaultSeparators = {
 ["sep"]      = {" "},
 ["sep%s"]    = {","},
 ["sep%q"]    = {"; "},
 ["sep%q\\d"] = {", "},
 ["sep%r"]    = nil,  -- none
 ["punc"]     = nil   -- none
}

local rankTable = {
 ["preferred"]  = 1,
 ["normal"]     = 2,
 ["deprecated"] = 3
}

local function replaceAlias(id)
 if aliasesP[id] then
  id = aliasesP[id]
 end

 return id
end

local function errorText(code, param)
 local text = i18n["errors"][code]
 if param then text = mw.ustring.gsub(text, "$1", param) end
 return text
end

local function throwError(errorMessage, param)
 error(errorText(errorMessage, param))
end

local function replaceDecimalMark(num)
 return mw.ustring.gsub(num, "[.]", i18n['numeric']['decimal-mark'], 1)
end

local function padZeros(num, numDigits)
 local numZeros
 local negative = false

 if num < 0 then
  negative = true
  num = num * -1
 end

 num = tostring(num)
 numZeros = numDigits - num:len()

 for _ = 1, numZeros do
  num = "0"..num
 end

 if negative then
  num = "-"..num
 end

 return num
end

local function replaceSpecialChar(chr)
 if chr == '_' then
  -- replace underscores with spaces
  return ' '
 else
  return chr
 end
end

local function replaceSpecialChars(str)
 local chr
 local esc = false
 local strOut = ""

 for i = 1, #str do
  chr = str:sub(i,i)

  if not esc then
   if chr == '\\' then
    esc = true
   else
    strOut = strOut .. replaceSpecialChar(chr)
   end
  else
   strOut = strOut .. chr
   esc = false
  end
 end

 return strOut
end

local function buildWikilink(target, label)
 if not label or target == label then
  return "[[" .. target .. "]]"
 else
  return "[[" .. target .. "|" .. label .. "]]"
 end
end

-- used to make frame.args mutable, to replace #frame.args (which is always 0)
-- with the actual amount and to simply copy tables
local function copyTable(tIn)
 if not tIn then
  return nil
 end

 local tOut = {}

 for i, v in pairs(tIn) do
  tOut[i] = v
 end

 return tOut
end

-- used to merge output arrays together;
-- note that it currently mutates the first input array
local function mergeArrays(a1, a2)
 for i = 1, #a2 do
  a1[#a1 + 1] = a2[i]
 end

 return a1
end

local function split(str, del)
 local out = {}
 local i, j = str:find(del)

 if i and j then
  out[1] = str:sub(1, i - 1)
  out[2] = str:sub(j + 1)
 else
  out[1] = str
 end

 return out
end

local function parseWikidataURL(url)
 local id

 if url:match('^http[s]?://') then
  id = split(url, "Q")

  if id[2] then
   return "Q" .. id[2]
  end
 end

 return nil
end

local function parseDate(dateStr, precision)
 precision = precision or "d"

 local i, j, index, ptr
 local parts = {nil, nil, nil}

 if dateStr == nil then
  return parts[1], parts[2], parts[3]  -- year, month, day
 end

 -- 'T' for snak values, '/' for outputs with '/Julian' attached
 i, j = dateStr:find("[T/]")

 if i then
  dateStr = dateStr:sub(1, i-1)
 end

 local from = 1

 if dateStr:sub(1,1) == "-" then
  -- this is a negative number, look further ahead
  from = 2
 end

 index = 1
 ptr = 1

 i, j = dateStr:find("-", from)

 if i then
  -- year
  parts[index] = tonumber(dateStr:sub(ptr, i-1), 10)  -- explicitly give base 10 to prevent error

  if parts[index] == -0 then
   parts[index] = tonumber("0")  -- for some reason, 'parts[index] = 0' may actually store '-0', so parse from string instead
  end

  if precision == "y" then
   -- we're done
   return parts[1], parts[2], parts[3]  -- year, month, day
  end

  index = index + 1
  ptr = i + 1

  i, j = dateStr:find("-", ptr)

  if i then
   -- month
   parts[index] = tonumber(dateStr:sub(ptr, i-1), 10)

   if precision == "m" then
    -- we're done
    return parts[1], parts[2], parts[3]  -- year, month, day
   end

   index = index + 1
   ptr = i + 1
  end
 end

 if dateStr:sub(ptr) ~= "" then
  -- day if we have month, month if we have year, or year
  parts[index] = tonumber(dateStr:sub(ptr), 10)
 end

 return parts[1], parts[2], parts[3]  -- year, month, day
end

local function datePrecedesDate(aY, aM, aD, bY, bM, bD)
 if aY == nil or bY == nil then
  return nil
 end
 aM = aM or 1
 aD = aD or 1
 bM = bM or 1
 bD = bD or 1

 if aY < bY then
  return true
 end

 if aY > bY then
  return false
 end

 if aM < bM then
  return true
 end

 if aM > bM then
  return false
 end

 if aD < bD then
  return true
 end

 return false
end

local function getHookName(param, index)
 if hookNames[param] then
  return hookNames[param][index]
 elseif param:len() > 2 then
  return hookNames[param:sub(1, 2).."\\d"][index]
 else
  return nil
 end
end

local function alwaysTrue()
 return true
end

-- The following function parses a format string.
--
-- The example below shows how a parsed string is structured in memory.
-- Variables other than 'str' and 'child' are left out for clarity's sake.
--
-- Example:
-- "A %p B [%s[%q1]] C [%r] D"
--
-- Structure:
-- [
--   {
--     str = "A "
--   },
--   {
--     str = "%p"
--   },
--   {
--     str = " B ",
--     child =
--     [
--       {
--         str = "%s",
--         child =
--         [
--           {
--             str = "%q1"
--           }
--         ]
--       }
--     ]
--   },
--   {
--     str = " C ",
--     child =
--     [
--       {
--         str = "%r"
--       }
--     ]
--   },
--   {
--     str = " D"
--   }
-- ]
--
local function parseFormat(str)
 local chr, esc, param, root, cur, prev, new
 local params = {}

 local function newObject(array)
  local obj = {}  -- new object
  obj.str = ""

  array[#array + 1] = obj  -- array{object}
  obj.parent = array

  return obj
 end

 local function endParam()
  if param > 0 then
   if cur.str ~= "" then
    cur.str = "%"..cur.str
    cur.param = true
    params[cur.str] = true
    cur.parent.req[cur.str] = true
    prev = cur
    cur = newObject(cur.parent)
   end
   param = 0
  end
 end

 root = {}  -- array
 root.req = {}
 cur = newObject(root)
 prev = nil

 esc = false
 param = 0

 for i = 1, #str do
  chr = str:sub(i,i)

  if not esc then
   if chr == '\\' then
    endParam()
    esc = true
   elseif chr == '%' then
    endParam()
    if cur.str ~= "" then
     cur = newObject(cur.parent)
    end
    param = 2
   elseif chr == '[' then
    endParam()
    if prev and cur.str == "" then
     table.remove(cur.parent)
     cur = prev
    end
    cur.child = {}  -- new array
    cur.child.req = {}
    cur.child.parent = cur
    cur = newObject(cur.child)
   elseif chr == ']' then
    endParam()
    if cur.parent.parent then
     new = newObject(cur.parent.parent.parent)
     if cur.str == "" then
      table.remove(cur.parent)
     end
     cur = new
    end
   else
    if param > 1 then
     param = param - 1
    elseif param == 1 then
     if not chr:match('%d') then
      endParam()
     end
    end

    cur.str = cur.str .. replaceSpecialChar(chr)
   end
  else
   cur.str = cur.str .. chr
   esc = false
  end

  prev = nil
 end

 endParam()

 -- make sure that at least one required parameter has been defined
 if not next(root.req) then
  throwError("missing-required-parameter")
 end

 -- make sure that the separator parameter "%s" is not amongst the required parameters
 if root.req[parameters.separator] then
  throwError("extra-required-parameter", parameters.separator)
 end

 return root, params
end

local function sortOnRank(claims)
 local rankPos
 local ranks = {{}, {}, {}, {}}  -- preferred, normal, deprecated, (default)
 local sorted = {}

 for _, v in ipairs(claims) do
  rankPos = rankTable[v.rank] or 4
  ranks[rankPos][#ranks[rankPos] + 1] = v
 end

 sorted = ranks[1]
 sorted = mergeArrays(sorted, ranks[2])
 sorted = mergeArrays(sorted, ranks[3])

 return sorted
end

local Config = {}

-- allows for recursive calls
function Config:new()
 local cfg = {}
 setmetatable(cfg, self)
 self.__index = self

 cfg.separators = {
  -- single value objects wrapped in arrays so that we can pass by reference
  ["sep"]   = {copyTable(defaultSeparators["sep"])},
  ["sep%s"] = {copyTable(defaultSeparators["sep%s"])},
  ["sep%q"] = {copyTable(defaultSeparators["sep%q"])},
  ["sep%r"] = {copyTable(defaultSeparators["sep%r"])},
  ["punc"]  = {copyTable(defaultSeparators["punc"])}
 }

 cfg.entity = nil
 cfg.entityID = nil
 cfg.propertyID = nil
 cfg.propertyValue = nil
 cfg.qualifierIDs = {}
 cfg.qualifierIDsAndValues = {}

 cfg.bestRank = true
 cfg.ranks = {true, true, false}  -- preferred = true, normal = true, deprecated = false
 cfg.foundRank = #cfg.ranks
 cfg.flagBest = false
 cfg.flagRank = false

 cfg.periods = {true, true, true}  -- future = true, current = true, former = true
 cfg.flagPeriod = false
 cfg.atDate = {parseDate(os.date('!%Y-%m-%d'))}  -- today as {year, month, day}

 cfg.mdyDate = false
 cfg.singleClaim = false
 cfg.sourcedOnly = false
 cfg.editable = false
 cfg.editAtEnd = false

 cfg.inSitelinks = false

 cfg.langCode = mw.language.getContentLanguage().code
 cfg.langName = mw.language.fetchLanguageName(cfg.langCode, cfg.langCode)
 cfg.langObj = mw.language.new(cfg.langCode)

 cfg.siteID = mw.wikibase.getGlobalSiteId()

 cfg.states = {}
 cfg.states.qualifiersCount = 0
 cfg.curState = nil

 cfg.prefetchedRefs = nil

 return cfg
end

local State = {}

function State:new(cfg, type)
 local stt = {}
 setmetatable(stt, self)
 self.__index = self

 stt.conf = cfg
 stt.type = type

 stt.results = {}

 stt.parsedFormat = {}
 stt.separator = {}
 stt.movSeparator = {}
 stt.puncMark = {}

 stt.linked = false
 stt.rawValue = false
 stt.shortName = false
 stt.anyLanguage = false
 stt.unitOnly = false
 stt.singleValue = false

 return stt
end

-- if id == nil then item connected to current page is used
function Config:getLabel(id, raw, link, short)
 local label = nil
 local prefix, title= "", nil

 if not id then
  id = mw.wikibase.getEntityIdForCurrentPage()

  if not id then
   return ""
  end
 end

 id = id:upper()  -- just to be sure

 if raw then
  -- check if given id actually exists
  if mw.wikibase.isValidEntityId(id) and mw.wikibase.entityExists(id) then
   label = id
  end

  prefix, title = "d:Special:EntityPage/", label -- may be nil
 else
  -- try short name first if requested
  if short then
   label = p._property{aliasesP.shortName, [p.args.eid] = id}  -- get short name

   if label == "" then
    label = nil
   end
  end

  -- get label
  if not label then
   label = mw.wikibase.getLabelByLang(id, self.langCode) -- XXX: should use fallback labels?
  end
 end

 if not label then
  label = ""
 elseif link then
  -- build a link if requested
  if not title then
   if id:sub(1,1) == "Q" then
    title = mw.wikibase.getSitelink(id)
   elseif id:sub(1,1) == "P" then
    -- properties have no sitelink, link to Wikidata instead
    prefix, title = "d:Special:EntityPage/", id
   end
  end

  label = mw.text.nowiki(label) -- escape raw label text so it cannot be wikitext markup
  if title then
   label = buildWikilink(prefix .. title, label)
  end
 end

 return label
end

function Config:getEditIcon()
 local value = ""
 local prefix = ""
 local front = "&nbsp;"
 local back = ""

 if self.entityID:sub(1,1) == "P" then
  prefix = "Property:"
 end

 if self.editAtEnd then
  front = '<span style="float:'

  if self.langObj:isRTL() then
   front = front .. 'left'
  else
   front = front .. 'right'
  end

  front = front .. '">'
  back = '</span>'
 end

 value = "[[File:OOjs UI icon edit-ltr-progressive.svg|frameless|text-top|10px|alt=" .. i18n['info']['edit-on-wikidata'] .. "|link=https://www.wikidata.org/wiki/" .. prefix .. self.entityID .. "?uselang=" .. self.langCode

 if self.propertyID then
  value = value .. "#" .. self.propertyID
 elseif self.inSitelinks then
  value = value .. "#sitelinks-wikipedia"
 end

 value = value .. "|" .. i18n['info']['edit-on-wikidata'] .. "]]"

 return front .. value .. back
end

-- used to create the final output string when it's all done, so that for references the
-- function extensionTag("ref", ...) is only called when they really ended up in the final output
function Config:concatValues(valuesArray)
 local outString = ""
 local j, skip

 for i = 1, #valuesArray do
  -- check if this is a reference
  if valuesArray[i].refHash then
   j = i - 1
   skip = false

   -- skip this reference if it is part of a continuous row of references that already contains the exact same reference
   while valuesArray[j] and valuesArray[j].refHash do
    if valuesArray[i].refHash == valuesArray[j].refHash then
     skip = true
     break
    end
    j = j - 1
   end

   if not skip then
    -- add <ref> tag with the reference's hash as its name (to deduplicate references)
    outString = outString .. mw.getCurrentFrame():extensionTag("ref", valuesArray[i][1], {name = valuesArray[i].refHash})
   end
  else
   outString = outString .. valuesArray[i][1]
  end
 end

 return outString
end

function Config:convertUnit(unit, raw, link, short, unitOnly)
 local space = " "
 local label = ""
 local itemID

 if unit == "" or unit == "1" then
  return nil
 end

 if unitOnly then
  space = ""
 end

 itemID = parseWikidataURL(unit)

 if itemID then
  if itemID == aliasesQ.percentage then
   return "%"
  else
   label = self:getLabel(itemID, raw, link, short)

   if label ~= "" then
    return space .. label
   end
  end
 end

 return ""
end

function State:getValue(snak)
 return self.conf:getValue(snak, self.rawValue, self.linked, self.shortName, self.anyLanguage, self.unitOnly, false, self.type:sub(1,2))
end

function Config:getValue(snak, raw, link, short, anyLang, unitOnly, noSpecial, type)
 if snak.snaktype == 'value' then
  local datatype = snak.datavalue.type
  local subtype = snak.datatype
  local datavalue = snak.datavalue.value

  if datatype == 'string' then
   if subtype == 'url' and link then
    -- create link explicitly
    if raw then
     -- will render as a linked number like [1]
     return "[" .. datavalue .. "]"
    else
     return "[" .. datavalue .. " " .. datavalue .. "]"
    end
   elseif subtype == 'commonsMedia' then
    if link then
     return buildWikilink("c:File:" .. datavalue, datavalue)
    elseif not raw then
     return "[[File:" .. datavalue .. "]]"
    else
     return datavalue
    end
   elseif subtype == 'geo-shape' and link then
    return buildWikilink("c:" .. datavalue, datavalue)
   elseif subtype == 'math' and not raw then
    local attribute = nil

    if (type == parameters.property or (type == parameters.qualifier and self.propertyID == aliasesP.hasPart)) and snak.property == aliasesP.definingFormula then
     attribute = {qid = self.entityID}
    end

    return mw.getCurrentFrame():extensionTag("math", datavalue, attribute)
   elseif subtype == 'external-id' and link then
    local url = p._property{aliasesP.formatterURL, [p.args.eid] = snak.property}  -- get formatter URL

    if url ~= "" then
     url = mw.ustring.gsub(url, "$1", datavalue)
     return "[" .. url .. " " .. datavalue .. "]"
    else
     return datavalue
    end
   else
    return datavalue
   end
  elseif datatype == 'monolingualtext' then
   if anyLang or datavalue['language'] == self.langCode then
    return datavalue['text']
   else
    return nil
   end
  elseif datatype == 'quantity' then
   local value = ""
   local unit

   if not unitOnly then
    -- get value and strip + signs from front
    value = mw.ustring.gsub(datavalue['amount'], "^%+(.+)$", "%1")

    if raw then
     return value
    end

    -- replace decimal mark based on locale
    value = replaceDecimalMark(value)

    -- add delimiters for readability
    value = i18n.addDelimiters(value)
   end

   unit = self:convertUnit(datavalue['unit'], raw, link, short, unitOnly)

   if unit then
    value = value .. unit
   end

   return value
  elseif datatype == 'time' then
   local y, m, d, p, yDiv, yRound, yFull, value, calendarID, dateStr
   local yFactor = 1
   local sign = 1
   local prefix = ""
   local suffix = ""
   local mayAddCalendar = false
   local calendar = ""
   local precision = datavalue['precision']

   if precision == 11 then
    p = "d"
   elseif precision == 10 then
    p = "m"
   else
    p = "y"
    yFactor = 10^(9-precision)
   end

   y, m, d = parseDate(datavalue['time'], p)

   if y < 0 then
    sign = -1
    y = y * sign
   end

   -- if precision is tens/hundreds/thousands/millions/billions of years
   if precision <= 8 then
    yDiv = y / yFactor

    -- if precision is tens/hundreds/thousands of years
    if precision >= 6 then
     mayAddCalendar = true

     if precision <= 7 then
      -- round centuries/millenniums up (e.g. 20th century or 3rd millennium)
      yRound = math.ceil(yDiv)

      if not raw then
       if precision == 6 then
        suffix = i18n['datetime']['suffixes']['millennium']
       else
        suffix = i18n['datetime']['suffixes']['century']
       end

       suffix = i18n.getOrdinalSuffix(yRound) .. suffix
      else
       -- if not verbose, take the first year of the century/millennium
       -- (e.g. 1901 for 20th century or 2001 for 3rd millennium)
       yRound = (yRound - 1) * yFactor + 1
      end
     else
      -- precision == 8
      -- round decades down (e.g. 2010s)
      yRound = math.floor(yDiv) * yFactor

      if not raw then
       prefix = i18n['datetime']['prefixes']['decade-period']
       suffix = i18n['datetime']['suffixes']['decade-period']
      end
     end

     if raw and sign < 0 then
      -- if BCE then compensate for "counting backwards"
      -- (e.g. -2019 for 2010s BCE, -2000 for 20th century BCE or -3000 for 3rd millennium BCE)
      yRound = yRound + yFactor - 1
     end
    else
     local yReFactor, yReDiv, yReRound

     -- round to nearest for tens of thousands of years or more
     yRound = math.floor(yDiv + 0.5)

     if yRound == 0 then
      if precision <= 2 and y ~= 0 then
       yReFactor = 1e6
       yReDiv = y / yReFactor
       yReRound = math.floor(yReDiv + 0.5)

       if yReDiv == yReRound then
        -- change precision to millions of years only if we have a whole number of them
        precision = 3
        yFactor = yReFactor
        yRound = yReRound
       end
      end

      if yRound == 0 then
       -- otherwise, take the unrounded (original) number of years
       precision = 5
       yFactor = 1
       yRound = y
       mayAddCalendar = true
      end
     end

     if precision >= 1 and y ~= 0 then
      yFull = yRound * yFactor

      yReFactor = 1e9
      yReDiv = yFull / yReFactor
      yReRound = math.floor(yReDiv + 0.5)

      if yReDiv == yReRound then
       -- change precision to billions of years if we're in that range
       precision = 0
       yFactor = yReFactor
       yRound = yReRound
      else
       yReFactor = 1e6
       yReDiv = yFull / yReFactor
       yReRound = math.floor(yReDiv + 0.5)

       if yReDiv == yReRound then
        -- change precision to millions of years if we're in that range
        precision = 3
        yFactor = yReFactor
        yRound = yReRound
       end
      end
     end

     if not raw then
      if precision == 3 then
       suffix = i18n['datetime']['suffixes']['million-years']
      elseif precision == 0 then
       suffix = i18n['datetime']['suffixes']['billion-years']
      else
       yRound = yRound * yFactor
       if yRound == 1 then
        suffix = i18n['datetime']['suffixes']['year']
       else
        suffix = i18n['datetime']['suffixes']['years']
       end
      end
     else
      yRound = yRound * yFactor
     end
    end
   else
    yRound = y
    mayAddCalendar = true
   end

   if mayAddCalendar then
    calendarID = parseWikidataURL(datavalue['calendarmodel'])

    if calendarID and calendarID == aliasesQ.prolepticJulianCalendar then
     if not raw then
      if link then
       calendar = " ("..buildWikilink(i18n['datetime']['julian-calendar'], i18n['datetime']['julian'])..")"
      else
       calendar = " ("..i18n['datetime']['julian']..")"
      end
     else
      calendar = "/"..i18n['datetime']['julian']
     end
    end
   end

   if not raw then
    local ce = nil

    if sign < 0 then
     ce = i18n['datetime']['BCE']
    elseif precision <= 5 then
     ce = i18n['datetime']['CE']
    end

    if ce then
     if link then
      ce = buildWikilink(i18n['datetime']['common-era'], ce)
     end
     suffix = suffix .. " " .. ce
    end

    value = tostring(yRound)

    if m then
     dateStr = self.langObj:formatDate("F", "1-"..m.."-1")

     if d then
      if self.mdyDate then
       dateStr = dateStr .. " " .. d .. ","
      else
       dateStr = d .. " " .. dateStr
      end
     end

     value = dateStr .. " " .. value
    end

    value = prefix .. value .. suffix .. calendar
   else
    value = padZeros(yRound * sign, 4)

    if m then
     value = value .. "-" .. padZeros(m, 2)

     if d then
      value = value .. "-" .. padZeros(d, 2)
     end
    end

    value = value .. calendar
   end

   return value
  elseif datatype == 'globecoordinate' then
   -- logic from https://github.com/DataValues/Geo (v4.0.1)

   local precision, unitsPerDegree, numDigits, strFormat, value, globe
   local latitude, latConv, latValue, latLink
   local longitude, lonConv, lonValue, lonLink
   local latDirection, latDirectionN, latDirectionS, latDirectionEN
   local lonDirection, lonDirectionE, lonDirectionW, lonDirectionEN
   local degSymbol, minSymbol, secSymbol, separator

   local latDegrees = nil
   local latMinutes = nil
   local latSeconds = nil
   local lonDegrees = nil
   local lonMinutes = nil
   local lonSeconds = nil

   local latDegSym = ""
   local latMinSym = ""
   local latSecSym = ""
   local lonDegSym = ""
   local lonMinSym = ""
   local lonSecSym = ""

   local latDirectionEN_N = "N"
   local latDirectionEN_S = "S"
   local lonDirectionEN_E = "E"
   local lonDirectionEN_W = "W"

   if not raw then
    latDirectionN = i18n['coord']['latitude-north']
    latDirectionS = i18n['coord']['latitude-south']
    lonDirectionE = i18n['coord']['longitude-east']
    lonDirectionW = i18n['coord']['longitude-west']

    degSymbol = i18n['coord']['degrees']
    minSymbol = i18n['coord']['minutes']
    secSymbol = i18n['coord']['seconds']
    separator = i18n['coord']['separator']
   else
    latDirectionN = latDirectionEN_N
    latDirectionS = latDirectionEN_S
    lonDirectionE = lonDirectionEN_E
    lonDirectionW = lonDirectionEN_W

    degSymbol = "/"
    minSymbol = "/"
    secSymbol = "/"
    separator = "/"
   end

   latitude = datavalue['latitude']
   longitude = datavalue['longitude']

   if latitude < 0 then
    latDirection = latDirectionS
    latDirectionEN = latDirectionEN_S
    latitude = math.abs(latitude)
   else
    latDirection = latDirectionN
    latDirectionEN = latDirectionEN_N
   end

   if longitude < 0 then
    lonDirection = lonDirectionW
    lonDirectionEN = lonDirectionEN_W
    longitude = math.abs(longitude)
   else
    lonDirection = lonDirectionE
    lonDirectionEN = lonDirectionEN_E
   end

   precision = datavalue['precision']

   if not precision or precision <= 0 then
    precision = 1 / 3600  -- precision not set (correctly), set to arcsecond
   end

   -- remove insignificant detail
   latitude = math.floor(latitude / precision + 0.5) * precision
   longitude = math.floor(longitude / precision + 0.5) * precision

   if precision >= 1 - (1 / 60) and precision < 1 then
    precision = 1
   elseif precision >= (1 / 60) - (1 / 3600) and precision < (1 / 60) then
    precision = 1 / 60
   end

   if precision >= 1 then
    unitsPerDegree = 1
   elseif precision >= (1 / 60)  then
    unitsPerDegree = 60
   else
    unitsPerDegree = 3600
   end

   numDigits = math.ceil(-math.log10(unitsPerDegree * precision))

   if numDigits <= 0 then
    numDigits = tonumber("0")  -- for some reason, 'numDigits = 0' may actually store '-0', so parse from string instead
   end

   strFormat = "%." .. numDigits .. "f"

   if precision >= 1 then
    latDegrees = strFormat:format(latitude)
    lonDegrees = strFormat:format(longitude)

    if not raw then
     latDegSym = replaceDecimalMark(latDegrees) .. degSymbol
     lonDegSym = replaceDecimalMark(lonDegrees) .. degSymbol
    else
     latDegSym = latDegrees .. degSymbol
     lonDegSym = lonDegrees .. degSymbol
    end
   else
    latConv = math.floor(latitude * unitsPerDegree * 10^numDigits + 0.5) / 10^numDigits
    lonConv = math.floor(longitude * unitsPerDegree * 10^numDigits + 0.5) / 10^numDigits

    if precision >= (1 / 60) then
     latMinutes = latConv
     lonMinutes = lonConv
    else
     latSeconds = latConv
     lonSeconds = lonConv

     latMinutes = math.floor(latSeconds / 60)
     lonMinutes = math.floor(lonSeconds / 60)

     latSeconds = strFormat:format(latSeconds - (latMinutes * 60))
     lonSeconds = strFormat:format(lonSeconds - (lonMinutes * 60))

     if not raw then
      latSecSym = replaceDecimalMark(latSeconds) .. secSymbol
      lonSecSym = replaceDecimalMark(lonSeconds) .. secSymbol
     else
      latSecSym = latSeconds .. secSymbol
      lonSecSym = lonSeconds .. secSymbol
     end
    end

    latDegrees = math.floor(latMinutes / 60)
    lonDegrees = math.floor(lonMinutes / 60)

    latDegSym = latDegrees .. degSymbol
    lonDegSym = lonDegrees .. degSymbol

    latMinutes = latMinutes - (latDegrees * 60)
    lonMinutes = lonMinutes - (lonDegrees * 60)

    if precision >= (1 / 60) then
     latMinutes = strFormat:format(latMinutes)
     lonMinutes = strFormat:format(lonMinutes)

     if not raw then
      latMinSym = replaceDecimalMark(latMinutes) .. minSymbol
      lonMinSym = replaceDecimalMark(lonMinutes) .. minSymbol
     else
      latMinSym = latMinutes .. minSymbol
      lonMinSym = lonMinutes .. minSymbol
     end
    else
     latMinSym = latMinutes .. minSymbol
     lonMinSym = lonMinutes .. minSymbol
    end
   end

   latValue = latDegSym .. latMinSym .. latSecSym .. latDirection
   lonValue = lonDegSym .. lonMinSym .. lonSecSym .. lonDirection

   value = latValue .. separator .. lonValue

   if link then
    globe = parseWikidataURL(datavalue['globe'])

    if globe then
     globe = mw.wikibase.getLabelByLang(globe, "en"):lower()
    else
     globe = "earth"
    end

    latLink = table.concat({latDegrees, latMinutes, latSeconds}, "_")
    lonLink = table.concat({lonDegrees, lonMinutes, lonSeconds}, "_")

    value = "[https://geohack.toolforge.org/geohack.php?language="..self.langCode.."&params="..latLink.."_"..latDirectionEN.."_"..lonLink.."_"..lonDirectionEN.."_globe:"..globe.." "..value.."]"
   end

   return value
  elseif datatype == 'wikibase-entityid' then
   local label
   local itemID = datavalue['numeric-id']

   if subtype == 'wikibase-item' then
    itemID = "Q" .. itemID
   elseif subtype == 'wikibase-property' then
    itemID = "P" .. itemID
   else
    return '<strong class="error">' .. errorText('unknown-data-type', subtype) .. '</strong>'
   end

   label = self:getLabel(itemID, raw, link, short)

   if label == "" then
    label = nil
   end

   return label
  else
   return '<strong class="error">' .. errorText('unknown-data-type', datatype) .. '</strong>'
  end
 elseif snak.snaktype == 'somevalue' and not noSpecial then
  if raw then
   return " "  -- single space represents 'somevalue'
  else
   return i18n['values']['unknown']
  end
 elseif snak.snaktype == 'novalue' and not noSpecial then
  if raw then
   return ""  -- empty string represents 'novalue'
  else
   return i18n['values']['none']
  end
 else
  return nil
 end
end

function Config:getSingleRawQualifier(claim, qualifierID)
 local qualifiers

 if claim.qualifiers then qualifiers = claim.qualifiers[qualifierID] end

 if qualifiers and qualifiers[1] then
  return self:getValue(qualifiers[1], true)  -- raw = true
 else
  return nil
 end
end

function Config:snakEqualsValue(snak, value)
 local snakValue = self:getValue(snak, true)  -- raw = true

 if snakValue and snak.snaktype == 'value' and snak.datavalue.type == 'wikibase-entityid' then value = value:upper() end

 return snakValue == value
end

function Config:setRank(rank)
 local rankPos

 if rank == p.flags.best then
  self.bestRank = true
  self.flagBest = true  -- mark that 'best' flag was given
  return
 end

 if rank:sub(1,9) == p.flags.preferred then
  rankPos = 1
 elseif rank:sub(1,6) == p.flags.normal then
  rankPos = 2
 elseif rank:sub(1,10) == p.flags.deprecated then
  rankPos = 3
 else
  return
 end

 -- one of the rank flags was given, check if another one was given before
 if not self.flagRank then
  self.ranks = {false, false, false}  -- no other rank flag given before, so unset ranks
  self.bestRank = self.flagBest       -- unsets bestRank only if 'best' flag was not given before
  self.flagRank = true                -- mark that a rank flag was given
 end

 if rank:sub(-1) == "+" then
  for i = rankPos, 1, -1 do
   self.ranks[i] = true
  end
 elseif rank:sub(-1) == "-" then
  for i = rankPos, #self.ranks do
   self.ranks[i] = true
  end
 else
  self.ranks[rankPos] = true
 end
end

function Config:setPeriod(period)
 local periodPos

 if period == p.flags.future then
  periodPos = 1
 elseif period == p.flags.current then
  periodPos = 2
 elseif period == p.flags.former then
  periodPos = 3
 else
  return
 end

 -- one of the period flags was given, check if another one was given before
 if not self.flagPeriod then
  self.periods = {false, false, false}  -- no other period flag given before, so unset periods
  self.flagPeriod = true                -- mark that a period flag was given
 end

 self.periods[periodPos] = true
end

function Config:qualifierMatches(claim, id, value)
 local qualifiers

 if claim.qualifiers then qualifiers = claim.qualifiers[id] end
 if qualifiers then
  for _, v in pairs(qualifiers) do
   if self:snakEqualsValue(v, value) then
    return true
   end
  end
 elseif value == "" then
  -- if the qualifier is not present then treat it the same as the special value 'novalue'
  return true
 end

 return false
end

function Config:rankMatches(rankPos)
 if self.bestRank then
  return (self.ranks[rankPos] and self.foundRank >= rankPos)
 else
  return self.ranks[rankPos]
 end
end

function Config:timeMatches(claim)
 local startTime = nil
 local startTimeY = nil
 local startTimeM = nil
 local startTimeD = nil
 local endTime = nil
 local endTimeY = nil
 local endTimeM = nil
 local endTimeD = nil

 if self.periods[1] and self.periods[2] and self.periods[3] then
  -- any time
  return true
 end

 startTime = self:getSingleRawQualifier(claim, aliasesP.startTime)
 if startTime and startTime ~= "" and startTime ~= " " then
  startTimeY, startTimeM, startTimeD = parseDate(startTime)
 end

 endTime = self:getSingleRawQualifier(claim, aliasesP.endTime)
 if endTime and endTime ~= "" and endTime ~= " " then
  endTimeY, endTimeM, endTimeD = parseDate(endTime)
 end

 if startTimeY ~= nil and endTimeY ~= nil and datePrecedesDate(endTimeY, endTimeM, endTimeD, startTimeY, startTimeM, startTimeD) then
  -- invalidate end time if it precedes start time
  endTimeY = nil
  endTimeM = nil
  endTimeD = nil
 end

 if self.periods[1] then
  -- future
  if startTimeY and datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], startTimeY, startTimeM, startTimeD) then
   return true
  end
 end

 if self.periods[2] then
  -- current
  if (startTimeY == nil or not datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], startTimeY, startTimeM, startTimeD)) and
     (endTimeY == nil or datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], endTimeY, endTimeM, endTimeD)) then
   return true
  end
 end

 if self.periods[3] then
  -- former
  if endTimeY and not datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], endTimeY, endTimeM, endTimeD) then
   return true
  end
 end

 return false
end

function Config:processFlag(flag)
 if not flag then
  return false
 end

 if flag == p.flags.linked then
  self.curState.linked = true
  return true
 elseif flag == p.flags.raw then
  self.curState.rawValue = true

  if self.curState == self.states[parameters.reference] then
   -- raw reference values end with periods and require a separator (other than none)
   self.separators["sep%r"][1] = {" "}
  end

  return true
 elseif flag == p.flags.short then
  self.curState.shortName = true
  return true
 elseif flag == p.flags.multilanguage then
  self.curState.anyLanguage = true
  return true
 elseif flag == p.flags.unit then
  self.curState.unitOnly = true
  return true
 elseif flag == p.flags.mdy then
  self.mdyDate = true
  return true
 elseif flag == p.flags.single then
  self.singleClaim = true
  return true
 elseif flag == p.flags.sourced then
  self.sourcedOnly = true
  return true
 elseif flag == p.flags.edit then
  self.editable = true
  return true
 elseif flag == p.flags.editAtEnd then
  self.editable = true
  self.editAtEnd = true
  return true
 elseif flag == p.flags.best or flag:match('^'..p.flags.preferred..'[+-]?$') or flag:match('^'..p.flags.normal..'[+-]?$') or flag:match('^'..p.flags.deprecated..'[+-]?$') then
  self:setRank(flag)
  return true
 elseif flag == p.flags.future or flag == p.flags.current or flag == p.flags.former then
  self:setPeriod(flag)
  return true
 elseif flag == "" then
  -- ignore empty flags and carry on
  return true
 else
  return false
 end
end

function Config:processFlagOrCommand(flag)
 local param = ""

 if not flag then
  return false
 end

 if flag == p.claimCommands.property or flag == p.claimCommands.properties then
  param = parameters.property
 elseif flag == p.claimCommands.qualifier or flag == p.claimCommands.qualifiers then
  self.states.qualifiersCount = self.states.qualifiersCount + 1
  param = parameters.qualifier .. self.states.qualifiersCount
  self.separators["sep"..param] = {copyTable(defaultSeparators["sep%q\\d"])}
 elseif flag == p.claimCommands.reference or flag == p.claimCommands.references then
  param = parameters.reference
 else
  return self:processFlag(flag)
 end

 if self.states[param] then
  return false
 end

 -- create a new state for each command
 self.states[param] = State:new(self, param)

 -- use "%x" as the general parameter name
 self.states[param].parsedFormat = parseFormat(parameters.general)  -- will be overwritten for param=="%p"

 -- set the separator
 self.states[param].separator = self.separators["sep"..param]  -- will be nil for param=="%p", which will be set separately

 if flag == p.claimCommands.property or flag == p.claimCommands.qualifier or flag == p.claimCommands.reference then
  self.states[param].singleValue = true
 end

 self.curState = self.states[param]

 return true
end

function Config:processSeparators(args)
 local sep

 for i, v in pairs(self.separators) do
  if args[i] then
   sep = replaceSpecialChars(args[i])

   if sep ~= "" then
    self.separators[i][1] = {sep}
   else
    self.separators[i][1] = nil
   end
  end
 end
end

function Config:setFormatAndSeparators(state, parsedFormat)
 state.parsedFormat = parsedFormat
 state.separator = self.separators["sep"]
 state.movSeparator = self.separators["sep"..parameters.separator]
 state.puncMark = self.separators["punc"]
end

-- determines if a claim has references by prefetching them from the claim using getReferences,
-- which applies some filtering that determines if a reference is actually returned,
-- and caches the references for later use
function State:isSourced(claim)
 self.conf.prefetchedRefs = self:getReferences(claim)
 return (#self.conf.prefetchedRefs > 0)
end

function State:resetCaches()
 -- any prefetched references of the previous claim must not be used
 self.conf.prefetchedRefs = nil
end

function State:claimMatches(claim)
 local matches, rankPos

 -- first of all, reset any cached values used for the previous claim
 self:resetCaches()

 -- if a property value was given, check if it matches the claim's property value
 if self.conf.propertyValue then
  matches = self.conf:snakEqualsValue(claim.mainsnak, self.conf.propertyValue)
 else
  matches = true
 end

 -- if any qualifier values were given, check if each matches one of the claim's qualifier values
 for i, v in pairs(self.conf.qualifierIDsAndValues) do
  matches = (matches and self.conf:qualifierMatches(claim, i, v))
 end

 -- check if the claim's rank and time period match
 rankPos = rankTable[claim.rank] or 4
 matches = (matches and self.conf:rankMatches(rankPos) and self.conf:timeMatches(claim))

 -- if only claims with references must be returned, check if this one has any
 if self.conf.sourcedOnly then
  matches = (matches and self:isSourced(claim))  -- prefetches and caches references
 end

 return matches, rankPos
end

function State:out()
 local result  -- collection of arrays with value objects
 local valuesArray  -- array with value objects
 local sep = nil  -- value object
 local out = {}  -- array with value objects

 local function walk(formatTable, result)
  local valuesArray = {}  -- array with value objects

  for i, v in pairs(formatTable.req) do
   if not result[i] or not result[i][1] then
    -- we've got no result for a parameter that is required on this level,
    -- so skip this level (and its children) by returning an empty result
    return {}
   end
  end

  for _, v in ipairs(formatTable) do
   if v.param then
    valuesArray = mergeArrays(valuesArray, result[v.str])
   elseif v.str ~= "" then
    valuesArray[#valuesArray + 1] = {v.str}
   end

   if v.child then
    valuesArray = mergeArrays(valuesArray, walk(v.child, result))
   end
  end

  return valuesArray
 end

 -- iterate through the results from back to front, so that we know when to add separators
 for i = #self.results, 1, -1 do
  result = self.results[i]

  -- if there is already some output, then add the separators
  if #out > 0 then
   sep = self.separator[1]  -- fixed separator
   result[parameters.separator] = {self.movSeparator[1]}  -- movable separator
  else
   sep = nil
   result[parameters.separator] = {self.puncMark[1]}  -- optional punctuation mark
  end

  valuesArray = walk(self.parsedFormat, result)

  if #valuesArray > 0 then
   if sep then
    valuesArray[#valuesArray + 1] = sep
   end

   out = mergeArrays(valuesArray, out)
  end
 end

 -- reset state before next iteration
 self.results = {}

 return out
end

-- level 1 hook
function State:getProperty(claim)
 local value = {self:getValue(claim.mainsnak)}  -- create one value object

 if #value > 0 then
  return {value}  -- wrap the value object in an array and return it
 else
  return {}  -- return empty array if there was no value
 end
end

-- level 1 hook
function State:getQualifiers(claim, param)
 local qualifiers

 if claim.qualifiers then qualifiers = claim.qualifiers[self.conf.qualifierIDs[param]] end
 if qualifiers then
  -- iterate through claim's qualifier statements to collect their values;
  -- return array with multiple value objects
  return self.conf.states[param]:iterate(qualifiers, {[parameters.general] = hookNames[parameters.qualifier.."\\d"][2], count = 1})  -- pass qualifier state with level 2 hook
 else
  return {}  -- return empty array
 end
end

-- level 2 hook
function State:getQualifier(snak)
 local value = {self:getValue(snak)}  -- create one value object

 if #value > 0 then
  return {value}  -- wrap the value object in an array and return it
 else
  return {}  -- return empty array if there was no value
 end
end

-- level 1 hook
function State:getAllQualifiers(claim, param, result, hooks)
 local out = {}  -- array with value objects
 local sep = self.conf.separators["sep"..parameters.qualifier][1]  -- value object

 -- iterate through the output of the separate "qualifier(s)" commands
 for i = 1, self.conf.states.qualifiersCount do

  -- if a hook has not been called yet, call it now
  if not result[parameters.qualifier..i] then
   self:callHook(parameters.qualifier..i, hooks, claim, result)
  end

  -- if there is output for this particular "qualifier(s)" command, then add it
  if result[parameters.qualifier..i] and result[parameters.qualifier..i][1] then

   -- if there is already some output, then add the separator
   if #out > 0 and sep then
    out[#out + 1] = sep
   end

   out = mergeArrays(out, result[parameters.qualifier..i])
  end
 end

 return out
end

-- level 1 hook
function State:getReferences(claim)
 if self.conf.prefetchedRefs then
  -- return references that have been prefetched by isSourced
  return self.conf.prefetchedRefs
 end

 if claim.references then
  -- iterate through claim's reference statements to collect their values;
  -- return array with multiple value objects
  return self.conf.states[parameters.reference]:iterate(claim.references, {[parameters.general] = hookNames[parameters.reference][2], count = 1})  -- pass reference state with level 2 hook
 else
  return {}  -- return empty array
 end
end

-- level 2 hook
function State:getReference(statement)
 local key, citeWeb, citeQ, label
 local params = {}
 local citeParams = {['web'] = {}, ['q'] = {}}
 local citeMismatch = {}
 local useCite = nil
 local useParams = nil
 local value = ""
 local ref = {}
 local referenceEmpty = true  -- will be set to false if at least one parameter is left unremoved
    local numAuthorParameters = 0
    local numAuthorNameStringParameters = 0
    local tempLink
    local additionalRefProperties = {}  -- will hold properties of the reference which are not in statement.snaks, namely backup title from "subject named as" and link from an external ID
    local wikidataPropertiesOfSource  -- will contain "Wikidata property" properties of the item in stated in, if any

 local version = 6  -- increment this each time the below logic is changed to avoid conflict errors

 if statement.snaks then
  -- don't include "imported from", which is added by a bot
  if statement.snaks[aliasesP.importedFrom] then
   statement.snaks[aliasesP.importedFrom] = nil
  end
  
  -- don't include "Wikimedia import URL"
  if statement.snaks[aliasesP.wikimediaImportURL] then
   statement.snaks[aliasesP.wikimediaImportURL] = nil
   -- don't include "retrieved" if no "referenceURL" is present,
   -- as "retrieved" probably belongs to "Wikimedia import URL"
   if statement.snaks[aliasesP.retrieved] and not statement.snaks[aliasesP.referenceURL] then
    statement.snaks[aliasesP.retrieved] = nil
   end
  end

  -- don't include "inferred from", which is added by a bot
  if statement.snaks[aliasesP.inferredFrom] then
   statement.snaks[aliasesP.inferredFrom] = nil
  end

  -- don't include "type of reference"
  if statement.snaks[aliasesP.typeOfReference] then
   statement.snaks[aliasesP.typeOfReference] = nil
  end

  -- don't include "image" to prevent littering
  if statement.snaks[aliasesP.image] then
   statement.snaks[aliasesP.image] = nil
  end

  -- don't include "language" if it is equal to the local one
  if self:getReferenceDetail(statement.snaks, aliasesP.language) == self.conf.langName then
   statement.snaks[aliasesP.language] = nil
  end
        
        if statement.snaks[aliasesP.statedIn] and not statement.snaks[aliasesP.referenceURL] then
         -- "stated in" was given but "reference URL" was not.
         -- get "Wikidata property" properties from the item in "stated in"
         -- if any of the returned properties of the external-id datatype is in statement.snaks, generate a link from it and use the link in the reference
         
         -- find the "Wikidata property" properties in the item from "stated in"
         wikidataPropertiesOfSource = mw.text.split(p._properties{p.flags.raw, aliasesP.wikidataProperty, [p.args.eid] = self.conf:getValue(statement.snaks[aliasesP.statedIn][1], true, false)}, ", ", true)
         for i, wikidataPropertyOfSource in pairs(wikidataPropertiesOfSource) do
          if statement.snaks[wikidataPropertyOfSource] and statement.snaks[wikidataPropertyOfSource][1].datatype == "external-id" then
           tempLink = self.conf:getValue(statement.snaks[wikidataPropertyOfSource][1], false, true)  -- not raw, linked
           if mw.ustring.match(tempLink, "^%[%Z- %Z+%]$") then  -- getValue returned a URL.
               additionalRefProperties[aliasesP.referenceURL] = mw.ustring.gsub(tempLink, "^%[(%Z-) %Z+%]$", "%1")  -- the link is in wiki markup, so strip the square brackets and the display text
               statement.snaks[wikidataPropertyOfSource] = nil
               break
           end
          end
         end
        end
        
        -- don't include "subject named as", but use it as the title when "title" is not present but a URL is
        if statement.snaks[aliasesP.subjectNamedAs] then
         if not statement.snaks[aliasesP.title] and (statement.snaks[aliasesP.referenceURL] or additionalRefProperties[aliasesP.referenceURL]) then
          additionalRefProperties[aliasesP.title] = statement.snaks[aliasesP.subjectNamedAs][1].datavalue.value
         end
         statement.snaks[aliasesP.subjectNamedAs] = nil
        end

  -- retrieve all the parameters
  for i in pairs(statement.snaks) do
   label = ""

   -- multiple authors may be given
   if i == aliasesP.author or i == aliasesP.authorNameString then
    params[i] = self:getReferenceDetails(statement.snaks, i, false, self.linked, true)  -- link = true/false, anyLang = true
   elseif i == aliasesP.statedIn then 
    -- Get "stated in" raw, as it is wanted (for Cite Q) even if it doesn't have a local language label.
    params[aliasesP.statedIn] = {self:getReferenceDetail(statement.snaks, aliasesP.statedIn, true)}  -- raw = true
   else
    params[i] = {self:getReferenceDetail(statement.snaks, i, false, self.linked and (statement.snaks[i][1].datatype ~= 'url'), true)}  -- link = true/false, anyLang = true
   end
   
   if #params[i] == 0 then
    params[i] = nil
   else
    referenceEmpty = false
    
    if statement.snaks[i][1].datatype == 'external-id' then
     key = "external-id"
     label = self.conf:getLabel(i)

     if label ~= "" then
      label = label .. " "
     end
    else
     key = i
    end

    -- add the parameter to each matching type of citation
    for j in pairs(citeParams) do
     -- do so if there was no mismatch with a previous parameter
     if not citeMismatch[j] then
      -- check if this parameter is not mismatching itself
      if i18n['cite'][j][key] then
       -- continue if an option is available in the corresponding cite template
       if i18n['cite'][j][key] ~= "" then
                                -- handle non-author properties (and author properties ("author" and "author name string"), if they don't use the same template parameter)
                                if (i ~= aliasesP.author and i ~= aliasesP.authorNameString) or (i18n['cite'][j][aliasesP.author] ~= i18n['cite'][j][aliasesP.authorNameString]) then
            citeParams[j][i18n['cite'][j][key]] = label .. params[i][1]
                                    -- to avoid problems with non-author multiple parameters (if existent), the following old code is retained
            for k=2, #params[i] do
                                        citeParams[j][i18n['cite'][j][key]..k] = label .. params[i][k]
            end
                                -- handle "author" and "author name string" specially if they use the same template parameter
                                elseif i == aliasesP.author or i == aliasesP.authorNameString then
                                    if params[aliasesP.author] ~= nil then
                                        numAuthorParameters = #params[aliasesP.author]
                                    else
                                        numAuthorParameters = 0
                                    end

                                    if params[aliasesP.authorNameString] ~= nil then
                                        numAuthorNameStringParameters = #params[aliasesP.authorNameString]
                                    else
                                        numAuthorNameStringParameters = 0
                                    end

                                    -- execute only if both "author" and "author name string" satisfy this condition: the property is both in params and in statement.snaks or it is neither in params nor in statement.snaks
                                    -- reason: parameters are added to params each iteration of the loop, not before the loop
                                    if ((statement.snaks[aliasesP.author] == nil) == (numAuthorParameters == 0)) and ((statement.snaks[aliasesP.authorNameString] == nil) == (numAuthorNameStringParameters == 0)) then
                                        for k=1, numAuthorParameters + numAuthorNameStringParameters do
                                            if k <= numAuthorParameters then  -- now handling the authors from the "author" property
                                                citeParams[j][i18n['cite'][j][aliasesP.author]..k] = label .. params[aliasesP.author][k]
                                            else  -- now handling the authors from "author name string"
                                                citeParams[j][i18n['cite'][j][aliasesP.authorNameString]..k] = label .. params[aliasesP.authorNameString][k - numAuthorParameters]
                                            end
                end
                                    end
                                end
       end
      else
       citeMismatch[j] = true
      end
     end
    end
   end
  end
  
  -- use additional properties
  for i in pairs(additionalRefProperties) do
   for j in pairs(citeParams) do
    if not citeMismatch[j] and i18n["cite"][j][i] then
     citeParams[j][i18n["cite"][j][i]] = additionalRefProperties[i]
    else
     citeMismatch[j] = true
    end
   end
  end

  -- get title of general template for citing web references
  citeWeb = split(mw.wikibase.getSitelink(aliasesQ.citeWeb) or "", ":")[2]  -- split off namespace from front

  -- get title of template that expands stated-in references into citations
  citeQ = split(mw.wikibase.getSitelink(aliasesQ.citeQ) or "", ":")[2]  -- split off namespace from front

  -- (1) use the general template for citing web references if there is a match and if at least both "reference URL" and "title" are present
  if citeWeb and not citeMismatch['web'] and citeParams['web'][i18n['cite']['web'][aliasesP.referenceURL]] and citeParams['web'][i18n['cite']['web'][aliasesP.title]] then
   -- we need a processed "stated in" for this template
   citeParams['web'][i18n['cite']['web'][aliasesP.statedIn]] = self:getReferenceDetail(statement.snaks, aliasesP.statedIn, false, self.linked, true)
   useCite = citeWeb
   useParams = citeParams['web']

  -- (2) use the template that expands stated-in references into citations if there is a match and if at least "stated in" is present
  elseif citeQ and not citeMismatch['q'] and citeParams['q'][i18n['cite']['q'][aliasesP.statedIn]] then
   useCite = citeQ
   useParams = citeParams['q']
  end

  if useCite and useParams then
   -- if this module is being substituted then build a regular template call, otherwise expand the template
   if mw.isSubsting() then
    for i, v in pairs(useParams) do
     value = value .. "|" .. i .. "=" .. v
    end

    value = "{{" .. useCite .. value .. "}}"
   else
    value = mw.getCurrentFrame():expandTemplate{title=useCite, args=useParams}
   end

  -- (3) if the citation couldn't be displayed using Cite web or Cite Q, but has properties other than the removed ones, throw an error
  elseif not referenceEmpty then
   value = "<span style=\"color:#dd3333\">" .. errorText("malformed-reference") .. "</span>"
  end
 
  if value ~= "" then
   value = {value}  -- create one value object

   if not self.rawValue then
    -- this should become a <ref> tag, so save the reference's hash for later
    value.refHash = "wikidata-" .. statement.hash .. "-v" .. (tonumber(i18n['cite']['version']) + version)
   end

   ref = {value}  -- wrap the value object in an array
  end
 end

 return ref
end

-- gets a detail of one particular type for a reference
function State:getReferenceDetail(snaks, dType, raw, link, anyLang)
 local switchLang = anyLang
 local value = nil

 if not snaks[dType] then
  return nil
 end

 -- if anyLang, first try the local language and otherwise any language
 repeat
  for _, v in ipairs(snaks[dType]) do
   value = self.conf:getValue(v, raw, link, false, anyLang and not switchLang, false, true)  -- noSpecial = true

   if value then
    break
   end
  end

  if value or not anyLang then
   break
  end

  switchLang = not switchLang
 until anyLang and switchLang

 return value
end

-- gets the details of one particular type for a reference
function State:getReferenceDetails(snaks, dType, raw, link, anyLang)
 local values = {}

 if not snaks[dType] then
  return {}
 end

 for _, v in ipairs(snaks[dType]) do
  -- if nil is returned then it will not be added to the table
  values[#values + 1] = self.conf:getValue(v, raw, link, false, anyLang, false, true)  -- noSpecial = true
 end

 return values
end

-- level 1 hook
function State:getAlias(object)
 local value = object.value
 local title = nil

 if value and self.linked then
  if self.conf.entityID:sub(1,1) == "Q" then
   title = mw.wikibase.getSitelink(self.conf.entityID)
  elseif self.conf.entityID:sub(1,1) == "P" then
   title = "d:Property:" .. self.conf.entityID
  end

  if title then
   value = buildWikilink(title, value)
  end
 end

 value = {value}  -- create one value object

 if #value > 0 then
  return {value}  -- wrap the value object in an array and return it
 else
  return {}  -- return empty array if there was no value
 end
end

-- level 1 hook
function State:getBadge(value)
 value = self.conf:getLabel(value, self.rawValue, self.linked, self.shortName)

 if value == "" then
  value = nil
 end

 value = {value}  -- create one value object

 if #value > 0 then
  return {value}  -- wrap the value object in an array and return it
 else
  return {}  -- return empty array if there was no value
 end
end

function State:callHook(param, hooks, statement, result)
 local valuesArray, refHash

 -- call a parameter's hook if it has been defined and if it has not been called before
 if not result[param] and hooks[param] then
  valuesArray = self[hooks[param]](self, statement, param, result, hooks)  -- array with value objects

  -- add to the result
  if #valuesArray > 0 then
   result[param] = valuesArray
   result.count = result.count + 1
  else
   result[param] = {}  -- an empty array to indicate that we've tried this hook already
   return true  -- miss == true
  end
 end

 return false
end

-- iterate through claims, claim's qualifiers or claim's references to collect values
function State:iterate(statements, hooks, matchHook)
 matchHook = matchHook or alwaysTrue

 local matches = false
 local rankPos = nil
 local result, gotRequired

 for _, v in ipairs(statements) do
  -- rankPos will be nil for non-claim statements (e.g. qualifiers, references, etc.)
  matches, rankPos = matchHook(self, v)

  if matches then
   result = {count = 0}  -- collection of arrays with value objects

   local function walk(formatTable)
    local miss

    for i2, v2 in pairs(formatTable.req) do
     -- call a hook, adding its return value to the result
     miss = self:callHook(i2, hooks, v, result)

     if miss then
      -- we miss a required value for this level, so return false
      return false
     end

     if result.count == hooks.count then
      -- we're done if all hooks have been called;
      -- returning at this point breaks the loop
      return true
     end
    end

    for _, v2 in ipairs(formatTable) do
     if result.count == hooks.count then
      -- we're done if all hooks have been called;
      -- returning at this point prevents further childs from being processed
      return true
     end

     if v2.child then
      walk(v2.child)
     end
    end

    return true
   end
   gotRequired = walk(self.parsedFormat)

   -- only append the result if we got values for all required parameters on the root level
   if gotRequired then
    -- if we have a rankPos (only with matchHook() for complete claims), then update the foundRank
    if rankPos and self.conf.foundRank > rankPos then
     self.conf.foundRank = rankPos
    end

    -- append the result
    self.results[#self.results + 1] = result

    -- break if we only need a single value
    if self.singleValue then
     break
    end
   end
  end
 end

 return self:out()
end

local function getEntityId(arg, eid, page, allowOmitPropPrefix, globalSiteId)
 local id = nil
 local prop = nil

 if arg then
  if arg:sub(1,1) == ":" then
   page = arg
   eid = nil
  elseif arg:sub(1,1):upper() == "Q" or arg:sub(1,9):lower() == "property:" or allowOmitPropPrefix then
   eid = arg
   page = nil
  else
   prop = arg
  end
 end

 if eid then
  if eid:sub(1,9):lower() == "property:" then
   id = replaceAlias(mw.text.trim(eid:sub(10)))

   if id:sub(1,1):upper() ~= "P" then
    id = ""
   end
  else
   id = replaceAlias(eid)
  end
 elseif page then
  if page:sub(1,1) == ":" then
   page = mw.text.trim(page:sub(2))
  end

  id = mw.wikibase.getEntityIdForTitle(page, globalSiteId) or ""
 end

 if not id then
  id = mw.wikibase.getEntityIdForCurrentPage() or ""
 end

 id = id:upper()

 if not mw.wikibase.isValidEntityId(id) then
  id = ""
 end

 return id, prop
end

local function nextArg(args)
 local arg = args[args.pointer]

 if arg then
  args.pointer = args.pointer + 1
  return mw.text.trim(arg)
 else
  return nil
 end
end

local function claimCommand(args, funcName)
 local cfg = Config:new()
 cfg:processFlagOrCommand(funcName)  -- process first command (== function name)

 local lastArg, parsedFormat, formatParams, claims, value
 local hooks = {count = 0}

 -- set the date if given;
 -- must come BEFORE processing the flags
 if args[p.args.date] then
  cfg.atDate = {parseDate(args[p.args.date])}
  cfg.periods = {false, true, false}  -- change default time constraint to 'current'
 end

 -- process flags and commands
 repeat
  lastArg = nextArg(args)
 until not cfg:processFlagOrCommand(lastArg)

 -- get the entity ID from either the positional argument, the eid argument or the page argument
 cfg.entityID, cfg.propertyID = getEntityId(lastArg, args[p.args.eid], args[p.args.page], false, args[p.args.globalSiteId])

 if cfg.entityID == "" then
  return ""  -- we cannot continue without a valid entity ID
 end

 cfg.entity = mw.wikibase.getEntity(cfg.entityID)

 if not cfg.propertyID then
  cfg.propertyID = nextArg(args)
 end

 cfg.propertyID = replaceAlias(cfg.propertyID)

 if not cfg.entity or not cfg.propertyID then
  return ""  -- we cannot continue without an entity or a property ID
 end

 cfg.propertyID = cfg.propertyID:upper()

 if not cfg.entity.claims or not cfg.entity.claims[cfg.propertyID] then
  return ""  -- there is no use to continue without any claims
 end

 claims = cfg.entity.claims[cfg.propertyID]

 if cfg.states.qualifiersCount > 0 then
  -- do further processing if "qualifier(s)" command was given

  if #args - args.pointer + 1 > cfg.states.qualifiersCount then
   -- claim ID or literal value has been given

   cfg.propertyValue = nextArg(args)
  end

  for i = 1, cfg.states.qualifiersCount do
   -- check if given qualifier ID is an alias and add it
   cfg.qualifierIDs[parameters.qualifier..i] = replaceAlias(nextArg(args) or ""):upper()
  end
 elseif cfg.states[parameters.reference] then
  -- do further processing if "reference(s)" command was given

  cfg.propertyValue = nextArg(args)
 end

 -- check for special property value 'somevalue' or 'novalue'
 if cfg.propertyValue then
  cfg.propertyValue = replaceSpecialChars(cfg.propertyValue)

  if cfg.propertyValue ~= "" and mw.text.trim(cfg.propertyValue) == "" then
   cfg.propertyValue = " "  -- single space represents 'somevalue', whereas empty string represents 'novalue'
  else
   cfg.propertyValue = mw.text.trim(cfg.propertyValue)
  end
 end

 -- parse the desired format, or choose an appropriate format
 if args["format"] then
  parsedFormat, formatParams = parseFormat(args["format"])
 elseif cfg.states.qualifiersCount > 0 then  -- "qualifier(s)" command given
  if cfg.states[parameters.property] then  -- "propert(y|ies)" command given
   parsedFormat, formatParams = parseFormat(formats.propertyWithQualifier)
  else
   parsedFormat, formatParams = parseFormat(formats.qualifier)
  end
 elseif cfg.states[parameters.property] then  -- "propert(y|ies)" command given
  parsedFormat, formatParams = parseFormat(formats.property)
 else  -- "reference(s)" command given
  parsedFormat, formatParams = parseFormat(formats.reference)
 end

 -- if a "qualifier(s)" command and no "propert(y|ies)" command has been given, make the movable separator a semicolon
 if cfg.states.qualifiersCount > 0 and not cfg.states[parameters.property] then
  cfg.separators["sep"..parameters.separator][1] = {";"}
 end

 -- if only "reference(s)" has been given, set the default separator to none (except when raw)
 if cfg.states[parameters.reference] and not cfg.states[parameters.property] and cfg.states.qualifiersCount == 0
    and not cfg.states[parameters.reference].rawValue then
  cfg.separators["sep"][1] = nil
 end

 -- if exactly one "qualifier(s)" command has been given, make "sep%q" point to "sep%q1" to make them equivalent
 if cfg.states.qualifiersCount == 1 then
  cfg.separators["sep"..parameters.qualifier] = cfg.separators["sep"..parameters.qualifier.."1"]
 end

 -- process overridden separator values;
 -- must come AFTER tweaking the default separators
 cfg:processSeparators(args)

 -- define the hooks that should be called (getProperty, getQualifiers, getReferences);
 -- only define a hook if both its command ("propert(y|ies)", "reference(s)", "qualifier(s)") and its parameter ("%p", "%r", "%q1", "%q2", "%q3") have been given
 for i, v in pairs(cfg.states) do
  -- e.g. 'formatParams["%q1"] or formatParams["%q"]' to define hook even if "%q1" was not defined to be able to build a complete value for "%q"
  if formatParams[i] or formatParams[i:sub(1, 2)] then
   hooks[i] = getHookName(i, 1)
   hooks.count = hooks.count + 1
  end
 end

 -- the "%q" parameter is not attached to a state, but is a collection of the results of multiple states (attached to "%q1", "%q2", "%q3", ...);
 -- so if this parameter is given then this hook must be defined separately, but only if at least one "qualifier(s)" command has been given
 if formatParams[parameters.qualifier] and cfg.states.qualifiersCount > 0 then
  hooks[parameters.qualifier] = getHookName(parameters.qualifier, 1)
  hooks.count = hooks.count + 1
 end

 -- create a state for "properties" if it doesn't exist yet, which will be used as a base configuration for each claim iteration;
 -- must come AFTER defining the hooks
 if not cfg.states[parameters.property] then
  cfg.states[parameters.property] = State:new(cfg, parameters.property)

  -- if the "single" flag has been given then this state should be equivalent to "property" (singular)
  if cfg.singleClaim then
   cfg.states[parameters.property].singleValue = true
  end
 end

 -- if the "sourced" flag has been given then create a state for "reference" if it doesn't exist yet, using default values,
 -- which must exist in order to be able to determine if a claim has any references;
 -- must come AFTER defining the hooks
 if cfg.sourcedOnly and not cfg.states[parameters.reference] then
  cfg:processFlagOrCommand(p.claimCommands.reference)  -- use singular "reference" to minimize overhead
 end

 -- set the parsed format and the separators (and optional punctuation mark);
 -- must come AFTER creating the additonal states
 cfg:setFormatAndSeparators(cfg.states[parameters.property], parsedFormat)

 -- process qualifier matching values, analogous to cfg.propertyValue
 for i, v in pairs(args) do
  i = tostring(i)

  if i:match('^[Pp]%d+$') or aliasesP[i] then
   v = replaceSpecialChars(v)

   -- check for special qualifier value 'somevalue'
   if v ~= "" and mw.text.trim(v) == "" then
    v = " "  -- single space represents 'somevalue'
   end

   cfg.qualifierIDsAndValues[replaceAlias(i):upper()] = v
  end
 end

 -- first sort the claims on rank to pre-define the order of output (preferred first, then normal, then deprecated)
 claims = sortOnRank(claims)

 -- then iterate through the claims to collect values
 value = cfg:concatValues(cfg.states[parameters.property]:iterate(claims, hooks, State.claimMatches))  -- pass property state with level 1 hooks and matchHook

 -- if desired, add a clickable icon that may be used to edit the returned values on Wikidata
 if cfg.editable and value ~= "" then
  value = value .. cfg:getEditIcon()
 end

 return value
end

local function generalCommand(args, funcName)
 local cfg = Config:new()
 cfg.curState = State:new(cfg)

 local lastArg
 local value = nil

 repeat
  lastArg = nextArg(args)
 until not cfg:processFlag(lastArg)

 -- get the entity ID from either the positional argument, the eid argument or the page argument
 cfg.entityID = getEntityId(lastArg, args[p.args.eid], args[p.args.page], true, args[p.args.globalSiteId])

 if cfg.entityID == "" or not mw.wikibase.entityExists(cfg.entityID) then
  return ""  -- we cannot continue without an entity
 end

 -- serve according to the given command
 if funcName == p.generalCommands.label then
  value = cfg:getLabel(cfg.entityID, cfg.curState.rawValue, cfg.curState.linked, cfg.curState.shortName)
 elseif funcName == p.generalCommands.title then
  cfg.inSitelinks = true

  if cfg.entityID:sub(1,1) == "Q" then
   value = mw.wikibase.getSitelink(cfg.entityID)
  end

  if cfg.curState.linked and value then
   value = buildWikilink(value)
  end
 elseif funcName == p.generalCommands.description then
  value = mw.wikibase.getDescription(cfg.entityID)
 else
  local parsedFormat, formatParams
  local hooks = {count = 0}

  cfg.entity = mw.wikibase.getEntity(cfg.entityID)

  if funcName == p.generalCommands.alias or funcName == p.generalCommands.badge then
   cfg.curState.singleValue = true
  end

  if funcName == p.generalCommands.alias or funcName == p.generalCommands.aliases then
   if not cfg.entity.aliases or not cfg.entity.aliases[cfg.langCode] then
    return ""  -- there is no use to continue without any aliasses
   end

   local aliases = cfg.entity.aliases[cfg.langCode]

   -- parse the desired format, or parse the default aliases format
   if args["format"] then
    parsedFormat, formatParams = parseFormat(args["format"])
   else
    parsedFormat, formatParams = parseFormat(formats.alias)
   end

   -- process overridden separator values;
   -- must come AFTER tweaking the default separators
   cfg:processSeparators(args)

   -- define the hook that should be called (getAlias);
   -- only define the hook if the parameter ("%a") has been given
   if formatParams[parameters.alias] then
    hooks[parameters.alias] = getHookName(parameters.alias, 1)
    hooks.count = hooks.count + 1
   end

   -- set the parsed format and the separators (and optional punctuation mark)
   cfg:setFormatAndSeparators(cfg.curState, parsedFormat)

   -- iterate to collect values
   value = cfg:concatValues(cfg.curState:iterate(aliases, hooks))
  elseif funcName == p.generalCommands.badge or funcName == p.generalCommands.badges then
   if not cfg.entity.sitelinks or not cfg.entity.sitelinks[cfg.siteID] or not cfg.entity.sitelinks[cfg.siteID].badges then
    return ""  -- there is no use to continue without any badges
   end

   local badges = cfg.entity.sitelinks[cfg.siteID].badges

   cfg.inSitelinks = true

   -- parse the desired format, or parse the default aliases format
   if args["format"] then
    parsedFormat, formatParams = parseFormat(args["format"])
   else
    parsedFormat, formatParams = parseFormat(formats.badge)
   end

   -- process overridden separator values;
   -- must come AFTER tweaking the default separators
   cfg:processSeparators(args)

   -- define the hook that should be called (getBadge);
   -- only define the hook if the parameter ("%b") has been given
   if formatParams[parameters.badge] then
    hooks[parameters.badge] = getHookName(parameters.badge, 1)
    hooks.count = hooks.count + 1
   end

   -- set the parsed format and the separators (and optional punctuation mark)
   cfg:setFormatAndSeparators(cfg.curState, parsedFormat)

   -- iterate to collect values
   value = cfg:concatValues(cfg.curState:iterate(badges, hooks))
  end
 end

 value = value or ""

 if cfg.editable and value ~= "" then
  -- if desired, add a clickable icon that may be used to edit the returned value on Wikidata
  value = value .. cfg:getEditIcon()
 end

 return value
end

-- modules that include this module should call the functions with an underscore prepended, e.g.: p._property(args)
local function establishCommands(commandList, commandFunc)
 for _, commandName in pairs(commandList) do
  local function wikitextWrapper(frame)
   local args = copyTable(frame.args)
   args.pointer = 1
   loadI18n(aliasesP, frame)
   return commandFunc(args, commandName)
  end
  p[commandName] = wikitextWrapper

  local function luaWrapper(args)
   args = copyTable(args)
   args.pointer = 1
   loadI18n(aliasesP)
   return commandFunc(args, commandName)
  end
  p["_" .. commandName] = luaWrapper
 end
end

establishCommands(p.claimCommands, claimCommand)
establishCommands(p.generalCommands, generalCommand)

-- main function that is supposed to be used by wrapper templates
function p.main(frame)
 if not mw.wikibase then return nil end

 local f, args

 loadI18n(aliasesP, frame)

 -- get the parent frame to take the arguments that were passed to the wrapper template
 frame = frame:getParent() or frame

 if not frame.args[1] then
  throwError("no-function-specified")
 end

 f = mw.text.trim(frame.args[1])

 if f == "main" then
  throwError("main-called-twice")
 end

 assert(p["_"..f], errorText('no-such-function', f))

 -- copy arguments from immutable to mutable table
 args = copyTable(frame.args)

 -- remove the function name from the list
 table.remove(args, 1)

 return p["_"..f](args)
end

return p