--
-- Copyright (c) 2021-2025 Zeping Lee
-- Released under the MIT license.
-- Repository: https://github.com/zepinglee/citeproc-lua
--

local output_module = {}

local lpeg = require("lpeg")
local uni_utf8
local unicode
local ir_node
local util

local using_luatex, _ = pcall(require, "kpse")
if using_luatex then
 uni_utf8 = require("unicode").utf8
 unicode = require("citeproc-unicode")
 ir_node = require("citeproc-ir-node")
 util = require("citeproc-util")
else
 uni_utf8 = require("lua-utf8")
 unicode = require("citeproc.unicode")
 ir_node = require("citeproc.ir-node")
 util = require("citeproc.util")
end

local GroupVar = ir_node.GroupVar


---@class LocalizedQuotes
local LocalizedQuotes = {
 outer_open = util.unicode["left double quotation mark"],
 outer_close = util.unicode["right double quotation mark"],
 inner_open = util.unicode["left single quotation mark"],
 inner_close = util.unicode["right single quotation mark"],
 punctuation_in_quote = false,
}

function LocalizedQuotes:new(outer_open, outer_close, inner_open, inner_close, punctuation_in_quote)
 local o = {
   outer_open = outer_open or util.unicode["left double quotation mark"],
   outer_close = outer_close or util.unicode["right double quotation mark"],
   inner_open = inner_open or util.unicode["left single quotation mark"],
   inner_close = inner_close or util.unicode["right single quotation mark"],
   punctuation_in_quote = punctuation_in_quote,
 }
 setmetatable(o, self)
 self.__index = self
 return o
end

-- Inspired by:
-- https://github.com/zotero/citeproc-rs/blob/master/crates/io/src/output/markup.rs#L67
-- https://hackage.haskell.org/package/pandoc-types-1.22.2.1/docs/Text-Pandoc-Definition.html
---@class InlineElement
---@field _type string
---@field _base_class string
---@field value string?
---@field inlines InlineElement[]?
local InlineElement = {
 _type = "InlineElement",
 _base_class = "InlineElement",
 value = nil,
 inlines = nil,
}


---@param class_name string
---@return table
function InlineElement:derive(class_name)
 local o = {
   _type = class_name,
 }
 -- self[class_name] = o
 setmetatable(o, self)
 self.__index = self
 o.__index = o
 return o
end

function InlineElement:new(inlines)
 local o = {
   inlines = inlines,
   _type = self._type,
 }
 setmetatable(o, self)
 return o
end


function InlineElement:_debug(level)
 level = level or 0
 local text = ""
 if level == 0 then
   text = "\n"
 end
 text = text .. self._type
 if self.formatting then
   text = text .. " ["
   for attr, value in pairs(self.formatting) do
     text = text .. attr .. '="' .. value .. '"'
   end
   text = text .. "] "
 end
 if self.is_inner then
   text = text .. " [inner quotes]"
 end
 text = text .. "("
 if self.value then
   text = text .. '"' .. self.value .. '"'
 elseif self.inlines then
   for _, inline in ipairs(self.inlines) do
     text = text .. "\n" .. string.rep("  ", level + 1) .. inline:_debug(level + 1) .. ", "
   end
   text = text .. "\n" .. string.rep("  ", level)
 end
 text = text .. ")"
 return text
end


---@class PlainText: InlineElement
local PlainText = InlineElement:derive("PlainText")

---@param value string
---@return PlainText
function PlainText:new(value)
 local o = InlineElement.new(self)
 o.value = value
 setmetatable(o, self)
 return o
end


---@class Formatted: InlineElement
---@field formatting table?
local Formatted = InlineElement:derive("Formatted")

---@param inlines InlineElement[]
---@param formatting table?
---@return Formatted
function Formatted:new(inlines, formatting)
 local o = InlineElement.new(self)
 o.inlines = inlines
 o.formatting = formatting
 setmetatable(o, self)
 return o
end


---@class Micro: InlineElement
local Micro = InlineElement:derive("Micro")

-- This is how we can flip-flop only user-supplied styling.
-- Inside this is parsed micro html
---@param inlines InlineElement[]
---@return Micro
function Micro:new(inlines)
 local o = InlineElement.new(self)
 o.inlines = inlines
 setmetatable(o, self)
 return o
end


---@class Quoted: InlineElement
---@field is_inner boolean
---@field quotes LocalizedQuotes
local Quoted = InlineElement:derive("Quoted")

---@param inlines InlineElement[]
---@param localized_quotes LocalizedQuotes?
---@param is_inner boolean?
---@return Quoted
function Quoted:new(inlines, localized_quotes, is_inner)
 local o = InlineElement.new(self)
 o.inlines = inlines
 o.is_inner = is_inner or false
 if localized_quotes then
   o.quotes = localized_quotes
 else
   o.quotes = LocalizedQuotes:new()
 end

 setmetatable(o, self)
 return o
end


---@class Code: InlineElement
local Code = InlineElement:derive("Code")

---@param value string
---@return Code
function Code:new(value)
 local o = InlineElement.new(self)
 o.value = value
 setmetatable(o, self)
 return o
end


---@class MathML: InlineElement
local MathML = InlineElement:derive("MathML")

---@param value string
---@return MathML
function MathML:new(value)
 local o = InlineElement.new(self)
 o.value = value
 setmetatable(o, self)
 return o
end


---@class MathTeX: InlineElement
local MathTeX = InlineElement:derive("MathTeX")

---@param value string
---@return MathTeX
function MathTeX:new(value)
 local o = InlineElement.new(self)
 o.value = value
 setmetatable(o, self)
 return o
end


---@class NoCase: InlineElement
local NoCase = InlineElement:derive("NoCase")

---@param inlines InlineElement[]
---@return NoCase
function NoCase:new(inlines)
 local o = InlineElement.new(self)
 o.inlines = inlines
 setmetatable(o, self)
 return o
end


---@class NoDecor: InlineElement
local NoDecor = InlineElement:derive("NoDecor")

---@param inlines InlineElement[]
---@return NoDecor
function NoDecor:new(inlines)
 local o = InlineElement.new(self)
 o.inlines = inlines
 setmetatable(o, self)
 return o
end


---@class Linked: InlineElement
---@field href string
local Linked = InlineElement:derive("Linked")

---@param value string
---@param href string
---@return Linked
function Linked:new(value, href)
 local o = InlineElement.new(self)
 o.value = value
 o.href = href
 setmetatable(o, self)
 return o
end


---@class Div: InlineElement
---@field div table?
local Div = InlineElement:derive("Div")

---@param inlines InlineElement[]
---@param display table?
---@return Div
function Div:new(inlines, display)
 local o = InlineElement.new(self)
 o.inlines = inlines
 o.div = display
 setmetatable(o, self)
 return o
end


---@class CiteInline: InlineElement
---@field cite_item CitationItem
local CiteInline = InlineElement:derive("CiteInline")

---@param inlines InlineElement[]
---@param cite_item CitationItem
---@return CiteInline
function CiteInline:new(inlines, cite_item)
 local o = InlineElement.new(self)
 o.inlines = inlines
 o.cite_item = cite_item
 setmetatable(o, self)
 return o
end


---@class UndefinedCite: InlineElement
---@field cite_item CitationItem
local UndefinedCite = InlineElement:derive("UndefinedCite")

---@param inlines InlineElement[]
---@param cite_item CitationItem
---@return UndefinedCite
function UndefinedCite:new(inlines, cite_item)
 local o = InlineElement.new(self)
 o.inlines = inlines
 o.cite_item = cite_item
 setmetatable(o, self)
 return o
end


---@param text string
---@param context Context?
---@param is_external boolean?
---@return InlineElement[]
function InlineElement:parse(text, context, is_external)
 local text_type = type(text)
 local inlines
 if text_type == "table" then
   -- CSL rich text
   inlines = self:parse_csl_rich_text(text)
 elseif text_type == "string" then
   -- String with HTML-like formatting tags
   inlines = self:parse_html_tags(text, context, is_external)
 elseif text_type == "number" then
   inlines = {PlainText:new(tostring(text))}
 else
   util.error("Invalid text type")
 end
 return inlines
end

---@param text string | (string | table)[]
---@return InlineElement[]
function InlineElement:parse_csl_rich_text(text)
 -- Example: [
 --   "A title with a",
 --   {
 --     "quote": "quoted string."
 --   }
 -- ]
 local inlines = {}

 local text_type = type(text)
 if text_type == "string" then
   table.insert(inlines, PlainText:new(text))
 elseif text_type == "table" then
   for _, subtext in ipairs(text) do
     local subtext_type = type(subtext)
     local inline
     if subtext_type == "string" then
       inline = PlainText:new(subtext)
     elseif subtext_type == "table" then
       local format
       local content
       for format_, content_ in pairs(subtext) do
         format = format_
         content = content_
       end
       if format == "bold" then
         inline = Formatted:new(self:parse_csl_rich_text(content), {["font-weight"] = "bold"})
       elseif format == "code" then
         if type(content) ~= "string" then
           util.error("Invalid rich text content.")
         end
         inline = Code:new(content)
       elseif format == "italic" then
         inline = Formatted:new(self:parse_csl_rich_text(content), {["font-style"] = "italic"})
       elseif format == "math-ml" then
         if type(content) ~= "string" then
           util.error("Invalid rich text content.")
         end
         inline = Code:new(content)
       elseif format == "math-tex" then
         if type(content) ~= "string" then
           util.error("Invalid rich text content.")
         end
         inline = Code:new(content)
       elseif format == "preserve" then
         inline = NoCase:new(self:parse_csl_rich_text(content))
       elseif format == "quote" then
         inline = Quoted:new(self:parse_csl_rich_text(content))
       elseif format == "sc" then
         inline = Formatted:new(self:parse_csl_rich_text(content), {["font-variant"] = "small-caps"})
       elseif format == "strike" then
         inline = Formatted:new(self:parse_csl_rich_text(content), {["strike-through"] = true})
       elseif format == "sub" then
         inline = Formatted:new(self:parse_csl_rich_text(content), {["font-variant"] = "small-caps"})
       elseif format == "sup" then
         inline = Formatted:new(self:parse_csl_rich_text(content), {["font-variant"] = "small-caps"})
       end
     end
     table.insert(inlines, inline)
   end
 else
   util.error("Invalid text type")
 end

 return inlines
end


local P = lpeg.P
local Ct = lpeg.Ct
local Cp = lpeg.Cp

-- Lua's regex doesn't support groups and thus we have to implement the same
-- logic with `lpeg`.
local code_pattern =
   Ct(Cp() * P("<code>") * Cp()) * ((1 - P("</code>")) ^ 0) *
   Ct(Cp() * P("</code>") * Cp())
   + Ct(Cp() * P("<script>") * Cp()) * ((1 - P("</script>")) ^ 0) *
   Ct(Cp() * P("</script>") * Cp())
   + Ct(Cp() * P("<pre>") * Cp()) * ((1 - P("</pre>")) ^ 0) *
   Ct(Cp() * P("</pre>") * Cp())
   + Ct(Cp() * P("<math>") * Cp()) * ((1 - P("</math>")) ^ 0) * Ct(Cp() * P("</math>") * Cp())
   + Ct(Cp() * P("<math-tex>") * Cp()) * ((1 - P("</math-tex>")) ^ 0) * Ct(Cp() * P("</math-tex>") * Cp())
local basic_tag_pattern = P '<span class="nocase">'
   + P '<span class="nodecor">'
   + P '<span style="font-variant:small-caps;">'
   + P "<sc>"
   + P "<i>"
   + P "<b>"
   + P ""
   + P ""
   + P ' "'
   + P " '"
   + P '("'
   + P "('"
   + P "“"
   + P "‘"
   + P "</span>"
   + P "</sc>"
   + P "</i>"
   + P "</b>"
   + P ""
   + P ""
   + P '"'
   + P "'"
   + P "”"
   + P "’"

local default_tag_pattern = Ct((code_pattern + Ct(Cp() * basic_tag_pattern * Cp()) + P(1)) ^ 0)

local default_openers_info = {
 ['<span class="nocase">'] = {
   closer = "</span>",
   quotes = false,
 },
 ['<span class="nodecor">'] = {
   closer = "</span>",
   quotes = false,
 },
 ['<span style="font-variant:small-caps;">'] = {
   closer = "</span>",
   quotes = false,
 },
 ["<sc>"] = {
   closer = "</sc>",
   quotes = false,
 },
 ["<i>"] = {
   closer = "</i>",
   quotes = false,
 },
 ["<b>"] = {
   closer = "</b>",
   quotes = false,
 },
 ["^{"] = {
   closer = "}",
   quotes = false,
 },
 ["_{"] = {
   closer = "}",
   quotes = false,
 },
 [' "'] = {
   closer = '"',
   quotes = true,
 },
 [" '"] = {
   closer = "'",
   quotes = true,
 },
 ["“"] = {
   closer = "”",
   quotes = true,
 },
 ["‘"] = {
   closer = "’",
   quotes = true,
 },
 ["<code>"] = {
   closer = "</code>",
   quotes = false,
 },
 ["<script>"] = {
   closer = "</script>",
   quotes = false,
 },
 ["<pre>"] = {
   closer = "</pre>",
   quotes = false,
 },
 ["<math>"] = {
   closer = "</math>",
   quotes = false,
 },
 ["<math-tex>"] = {
   closer = "</math-tex>",
   quotes = false,
 },
}

local function _quoted(str)
 str = string.gsub(str, "'", "\'")
 return string.format("'%s'", str)
end

---@param locale string
---@param context Context
local function make_locale_tag_info(locale, context)
 if context.engine.locale_tags_info_dict[locale] then
   return
 end
 local localed_quotes = context:get_localized_quotes()

 local tag_pattern = basic_tag_pattern
 local openers_info = util.deep_copy(default_openers_info)

 if localed_quotes.outer_open and localed_quotes.outer_close then
   tag_pattern = tag_pattern + P(_quoted(localed_quotes.outer_open))
   tag_pattern = tag_pattern + P(_quoted(localed_quotes.outer_close))

   openers_info[localed_quotes.outer_open] = {
     closer = localed_quotes.outer_close,
     quotes = true,
     inner = false,
   }
 end

 if localed_quotes.inner_open and localed_quotes.inner_close then
   tag_pattern = tag_pattern + P(_quoted(localed_quotes.inner_open))
   tag_pattern = tag_pattern + P(_quoted(localed_quotes.inner_close))

   openers_info[localed_quotes.inner_open] = {
     closer = localed_quotes.inner_close,
     quotes = true,
     inner = true,
   }
 end

 context.engine.locale_tags_info_dict[locale] = {
   tag_pattern = Ct((code_pattern + Ct(Cp() * tag_pattern * Cp()) + P(1)) ^ 0),
   openers_info = openers_info,
 }
end


local straight_quotes_flip = {
 [" '"] = ' "',
 [' "'] = " '",
};

---@param str any
---@param context Context?
---@return string[]
---@return string[]
local function split_tags_and_strings(str, context)
 local tags = {}
 local strings = {}

 str = string.gsub(str, '(<span)%s+(style="font%-variant:)%s*(small%-caps);?"[^>]*(>)', '%1 %2%3;"%4');

 str = string.gsub(str, '(<span)%s+(class="nocase")[^>]*(>)', "%1 %2%3");
 str = string.gsub(str, '(<span)%s+(class="nodecor")[^>]*(>)', "%1 %2%3");

 local tag_pattern = default_tag_pattern
 local openers_info = default_openers_info
 if context and context.lang then
   tag_pattern = context.engine.locale_tags_info_dict[context.lang].tag_pattern
 end

 local tag_positions_list = lpeg.match(tag_pattern, str)
 if not tag_positions_list then
   error("Pattern not match")
 end
 local start = 1
 local stop = 1
 local new_stop = 1
 for _, postion_tuple in ipairs(tag_positions_list) do
   start, new_stop = table.unpack(postion_tuple)
   table.insert(strings, string.sub(str, stop, start - 1))
   table.insert(tags, string.sub(str, start, new_stop - 1))
   stop = new_stop
 end
 table.insert(strings, string.sub(str, stop, -1))

 for i, tag in ipairs(tags) do
   if string.match(tag, "^.['\"]$") then
     strings[i] = strings[i] .. string.sub(tag, 1, 1)
     tags[i] = " " .. string.sub(tag, 2)
   elseif (tag == "'" or tag == '"') and strings[i] == "" and (i == 1 or openers_info[tags[i - 1]]) then
     -- See `bugreports_NoCaseEscape.txt`.
     -- '"PIAAC-Longitudinal (PIAAC-L) 2015"'
     -- <span class=\"nocase\">\"PIAAC-Longitudinal (PIAAC-Lx) 2015\"</span>
     tags[i] = " " .. tag
   end
 end

 return tags, strings
end


---@param tag string
---@param str string
---@return string?
local function _apostrophe_force(tag, str)
 if tag == "'" or tag == "’" then
   if str ~= "" and string.match(str, "^[^,.?:; ]") then
     return util.unicode["right single quotation mark"]
   end
 elseif (tag == " '" or tag == "’") and str ~= "" and string.match(str, "^%s") then
   return util.unicode["right single quotation mark"]
 end
 return nil
end


---@param quote string
---@param openers_info table
local function set_outer_quote_form(quote, openers_info)
 openers_info[quote].inner = false;
 openers_info[straight_quotes_flip[quote]].inner = true;
end


---@param tag string
---@param inlines InlineElement[]
---@param openers_info table
---@param context Context
---@return InlineElement
local function make_inline_from_tag(tag, inlines, openers_info, context)
 if tag == '<span class="nocase">' then
   return NoCase:new(inlines)
 elseif tag == '<span class="nodecor">' then
   return NoDecor:new(inlines)
 elseif tag == '<span style="font-variant:small-caps;">' then
   return Formatted:new(inlines, {["font-variant"] = "small-caps"})
 elseif tag == "<sc>" then
   return Formatted:new(inlines, {["font-variant"] = "small-caps"})
 elseif tag == "<i>" then
   return Formatted:new(inlines, {["font-style"] = "italic"})
 elseif tag == "<b>" then
   return Formatted:new(inlines, {["font-weight"] = "bold"})
 elseif tag == "<sup>" then
   return Formatted:new(inlines, {["vertical-align"] = "sup"})
 elseif tag == "<sub>" then
   return Formatted:new(inlines, {["vertical-align"] = "sub"})
 elseif openers_info[tag] and openers_info[tag].quotes then
   local localized_quotes = context:get_localized_quotes()
   return Quoted:new(inlines, localized_quotes, openers_info[tag].inner)
 elseif tag == "<code>" or tag == "<script>" or tag == "<pre>" then
   return Code:new(inlines[1].value)
 elseif tag == "<math>" or tag == "<math-tex>" then
   return MathTeX:new(inlines[1].value)
 else
   error(string.format("Invalid tag '%s'", tag))
   return PlainText:new("")
 end
end


--- processTags() in
--- <https://github.com/Juris-M/citeproc-js/blob/master/src/util_flipflop.js#L474>
---@param str string
---@param context Context?
---@param is_external boolean?
---@return InlineElement[]
function InlineElement:parse_html_tags(str, context, is_external)
 if str == "" then
   return {}
 end

 str = string.gsub(str, "(\u{00ab}) ", "\u{00ab}\u{202f}")
 str = string.gsub(str, " (\u{00bb})", "\u{202f}%1")
 str = string.gsub(str, " ([:;?!])", "\u{202f}%1")
 -- str = " " .. string.gsub(str, util.unicode["right single quotation mark"], "'")

 local openers_info = default_openers_info
 if context and context.lang then
   if not context.engine.locale_tags_info_dict[context.lang] then
     make_locale_tag_info(context.lang, context)
   end
   openers_info = context.engine.locale_tags_info_dict[context.lang].openers_info
 end

 local tags, strings = split_tags_and_strings(str, context)

 -- if #tags == 0 then
 --   return {PlainText:new(str)}
 -- end

 ---@type {tag: string, closer: string, pos: number}[]
 local opener_stack = {}

 for i, tag in ipairs(tags) do
   local apostrophe = _apostrophe_force(tag, strings[i + 1])
   if apostrophe then
     strings[i + 1] = apostrophe .. strings[i + 1]
     tags[i] = "";
   else
     local opener_info = openers_info[tag]
     local last_opener_info = opener_stack[#opener_stack]
     if opener_info then
       if opener_info.quotes and last_opener_info and tag == last_opener_info.tag then
         local pos = last_opener_info.pos
         strings[pos + 1] = string.gsub(tag, "^%s", "") .. strings[pos + 1]
         tags[pos] = "";
         table.remove(opener_stack)
       end
       table.insert(opener_stack, {
         tag = tag,
         closer = openers_info[tag].closer,
         pos = i,
       })
     else
       -- Closer tag
       if last_opener_info then
         if last_opener_info.closer == tag then
           table.remove(opener_stack)
         else
           if tag == "'" or tag == "’" then
             strings[i + 1] = "’" .. strings[i + 1]
             tags[i] = ""
           else
             while #opener_stack > 0 and opener_stack[#opener_stack].closer ~= tag do
               local pos = opener_stack[#opener_stack].pos
               strings[pos + 1] = tags[pos] .. strings[pos + 1]
               tags[pos] = ""
               table.remove(opener_stack)
             end
             if #opener_stack > 0 then
               table.remove(opener_stack)
             else
               strings[i + 1] = tags[i] .. strings[i + 1]
               tags[i] = ""
             end
           end
         end
       else
         if tag == "'" or tag == "’" then
           strings[i + 1] = "’" .. strings[i + 1]
           tags[i] = ""
         else
           strings[i + 1] = tags[i] .. strings[i + 1]
           tags[i] = ""
         end
       end
     end
   end
 end

 -- Process remainders in the stack
 if #opener_stack > 0 then
   for _, opener_info in ipairs(opener_stack) do
     local pos = opener_info.pos
     local orphan = string.gsub(tags[pos], "^%s", "")
     orphan = string.gsub(orphan, "'", "’")
     strings[pos + 1] = orphan .. strings[pos + 1]
     tags[pos] = ""
   end
 end

 -- Remove empty tag
 for i = #tags, 1, -1 do
   local tag = tags[i]
   if tag == "" then
     strings[i + 1] = strings[i] .. strings[i + 1]
     table.remove(strings, i)
     table.remove(tags, i)
   end
 end

 -- The first appearance of straight quote is treated as outer quote.
 for _, tag in ipairs(tags) do
   if straight_quotes_flip[tag] then
     set_outer_quote_form(tag, openers_info)
     break
   end
 end

 ---@type InlineElement[]
 local output = {}

 if strings[1] ~= "" then
   table.insert(output, PlainText:new(strings[1]))
 end

 ---@type {tag: string, closer: string, pos: number, output_pos: number}[]
 opener_stack = {}

 for i, tag in ipairs(tags) do
   if openers_info[tag] then
     table.insert(opener_stack, {
       tag = tag,
       closer = openers_info[tag].closer,
       pos = i,
       output_pos = #output + 1,
     })
   else
     assert(#opener_stack > 0)
     local opener_info = opener_stack[#opener_stack]
     assert(opener_info.closer == tag)
     local output_pos = opener_info.output_pos
     local inlines = util.slice(output, output_pos)
     for j = #output, output_pos, -1 do
       table.remove(output, j)
     end
     table.remove(opener_stack)
     local inline = make_inline_from_tag(opener_info.tag, inlines, openers_info, context)
     if inline._type == "Quoted" then
       ---@cast inline Quoted
       local quotes = context:get_localized_quotes()
       inline.punctuation_in_quote = quotes.punctuation_in_quote
     end
     table.insert(output, inline)
   end

   if strings[i + 1] ~= "" then
     table.insert(output, PlainText:new(strings[i + 1]))
   end

 end

 return output
end

local function merge_fragments_at(fragments, i)
 if type(fragments[i + 1]) == "string" then
   fragments[i] = fragments[i] .. fragments[i + 1]
   table.remove(fragments, i + 1)
 end
 if type(fragments[i - 1]) == "string" then
   fragments[i - 1] = fragments[i - 1] .. fragments[i]
   table.remove(fragments, i)
 end
end

-- Return a list of strings and InlineElement
function InlineElement:get_quote_fragments(inlines)
 local fragments = {}
 for _, inline in ipairs(inlines) do
   if inline._type == "PlainText" then
     local quote_tuples = {}
     for _, quote in ipairs({
       "'",
       '"',
       util.unicode["left single quotation mark"],
       util.unicode["right single quotation mark"],
       util.unicode["left double quotation mark"],
       util.unicode["right double quotation mark"],
       util.unicode["left-pointing double angle quotation mark"],
       util.unicode["right-pointing double angle quotation mark"],
     }) do
       string.gsub(inline.value, "()(" .. quote .. ")()", function (idx, qt, next_idx)
         table.insert(quote_tuples, {idx, qt, next_idx})
       end)
     end
     table.sort(quote_tuples, function (a, b)
       return a[1] < b[1]
     end)
     local start_idx = 1
     for _, quote_tuple in ipairs(quote_tuples) do
       local idx, qt, next_idx = table.unpack(quote_tuple)
       local fragment = string.sub(inline.value, start_idx, idx - 1)
       if fragment ~= "" then
         table.insert(fragments, fragment)
       end
       table.insert(fragments, qt)
       start_idx = next_idx
     end
     -- Insert last fragment
     local fragment = string.sub(inline.value, start_idx, #inline.value)
     if fragment ~= "" then
       table.insert(fragments, fragment)
     end
   else
     table.insert(fragments, inline)
   end

   for i = #fragments, 1, -1 do
     local fragment = fragments[i]
     if fragment == "'" or fragment == '"' then
       local left, right
       if i > 1 then
         left = fragments[i - 1]
         if type(left) == "table" then
           left = left:get_right_most_string()
         end
       end
       if i < #fragments then
         right = fragments[i + 1]
         if type(right) == "table" then
           right = right:get_left_most_string()
         end
       end
       -- TODO: consider utf-8
       if left and right then
         if string.match(left, "%s$") and string.match(right, "^%s") then
           -- Orphan quote: bugreports_SingleQuote.txt
           if fragment == "'" then
             fragments[i] = util.unicode["apostrophe"]
           end
           merge_fragments_at(fragments, i)
         end
         if not string.match(left, "[%s%p]$") and not string.match(right, "^[%s%p]") then
           if fragment == "'" then
             fragments[i] = util.unicode["apostrophe"]
           end
           merge_fragments_at(fragments, i)
         end
       end
     end
   end
 end
 return fragments
end

function InlineElement:get_left_most_string()
 if self.value then
   return self.value
 elseif self.inlines then
   return self.inlines[1]:get_left_most_string()
 end
end

function InlineElement:get_right_most_string()
 if self.value then
   return self.value
 elseif self.inlines then
   return self.inlines[#self.inlines]:get_left_most_string()
 end
end

function InlineElement:capitalize_first_term()
 if self._type == "PlainText" then
   self.value = unicode.capitalize(self.value)
 elseif self._type ~= "Code" and self._type ~= "MathML" and self._type ~= "MathTeX" then
   if self.inlines[1] then
     self.inlines[1]:capitalize_first_term()
   end
 end
end

--[[
Class inheritance hierarchical

OutputFormat
├── SortStringFormat
├── DisamStringFormat
└── Markup
   ├── LatexWriter
   ├── HtmlWriter
   └── PlainTextWriter
--]]

---@class OutputFormat
---@field name string
---@field markups table<string, string>
local OutputFormat = {

}

function OutputFormat:new(format_name)
 local o = {
   name = format_name,
   -- markups = {},
 }
 setmetatable(o, self)
 self.__index = self
 return o
end

function OutputFormat:flatten_ir(ir, override_delim)
 if self.group_var == GroupVar.Missing or self.collapse_suppressed then
   return {}
 end
 local inlines = {}
 if ir._type == "SeqIr" or ir._type == "NameIr" then
   inlines = self:flatten_seq_ir(ir, override_delim)
 else
   inlines = self:with_format(ir.inlines, ir.formatting)
   inlines = self:affixed_quoted(inlines, ir.affixes, ir.quotes);
   inlines = self:with_display(inlines, ir.display);
 end
 return inlines
end

---@param ir IrNode
---@param override_delim boolean
---@return InlineElement[]
function OutputFormat:flatten_seq_ir(ir, override_delim)
 -- if not ir.children then
 --   print(debug.traceback())
 -- end
 if #ir.children == 0 then
   return {}
 end
 local inlines_list = {}
 local delimiter = ir.delimiter
 if not delimiter and ir.should_inherit_delim then
   delimiter = override_delim
 end

 for _, child in ipairs(ir.children) do
   if child.group_var ~= GroupVar.Missing and not child.collapse_suppressed then
     local child_inlines = self:flatten_ir(child, delimiter)
     if #child_inlines > 0 then
       table.insert(inlines_list, child_inlines)
     end
   end
 end

 if #inlines_list == 0 then
   return {}
 end

 local inlines = self:group(inlines_list, delimiter, ir.formatting)
 -- assert ir.quotes == localized quotes
 inlines = self:affixed_quoted(inlines, ir.affixes, ir.quotes);
 inlines = self:with_display(inlines, ir.display);
 return inlines
end

function OutputFormat:group(inlines_list, delimiter, formatting)
 -- Each node is list of InlineElements
 if #inlines_list == 1 then
   return self:format_list(inlines_list[1], formatting)
 else
   local inlines = OutputFormat:join_many(inlines_list, delimiter)
   return self:format_list(inlines, formatting)
 end
end

function OutputFormat:format_list(inlines, formatting)
 if formatting then
   return {Formatted:new(inlines, formatting)}
 else
   return inlines
 end
end

function OutputFormat:join_many(lists, delimiter)
 local res = {}
 for i, list in ipairs(lists) do
   if delimiter and i > 1 then
     table.insert(res, PlainText:new(delimiter))
   end
   for _, el in ipairs(list) do
     table.insert(res, el)
   end
 end
 return res
end

function OutputFormat:with_format(inlines, formatting)
 return self:format_list(inlines, formatting)
end


---Check if there is a lowercase word not in CSL's stop words
---@param str string
---@return boolean
local function is_str_sentence_case(str)
 local words = unicode.words(str)
 for _, word in ipairs(words) do
   if unicode.islower(word) and not util.stop_words[word] then
     return true
   end
 end
 return false
end

---Returns true if the inlines contain a lowercase word which is not CSL's stop words.
---@param inlines table[]
---@return boolean
function OutputFormat:is_sentence_case(inlines)
 for _, inline in ipairs(inlines) do
   if util.is_instance(inline, PlainText) then
     if is_str_sentence_case(inline.value) then
       return true
     end

   elseif util.is_instance(inline, Quoted)
       or util.is_instance(inline, NoCase)
       or util.is_instance(inline, NoDecor)
       or util.is_instance(inline, CiteInline)
       or util.is_instance(inline, UndefinedCite)
       or (util.is_instance(inline, Formatted)
         and inline.formatting["font-variant"] ~= "small-caps"
         and inline.formatting["vertical-align"] ~= "sup"
         and inline.formatting["vertical-align"] ~= "sub") then
     if self:is_sentence_case(inline.inlines) then
       return true
     end
   end
 end
 return false
end

---1. For uppercase strings, the first character of the string remains capitalized.
---   All other letters are lowercased.
---2. For lower or mixed case strings, the first character of the first word is
---   capitalized if the word is lowercase.
---3. All other words are lowercased if capitalized.
---@param inlines table[]
---@param check_sentence_case boolean
function OutputFormat:convert_sentence_case(inlines, check_sentence_case)
 if not inlines or #inlines == 0 then
   return
 end
 local is_uppercase = false  -- TODO
 if check_sentence_case then
   if self:is_sentence_case(inlines) then
     self:apply_text_case_inner(inlines, "capitalize-first", false, is_uppercase)
   else
     self:apply_text_case_inner(inlines, "sentence-strong", false, is_uppercase)
   end
 else
   self:apply_text_case_inner(inlines, "sentence-strong", false, is_uppercase)
 end
end

function OutputFormat:apply_text_case(inlines, text_case, is_english)
 if not inlines or #inlines == 0 or not text_case then
   return
 end
 -- Title case conversion only affects English-language items.
 if text_case == "title" and not is_english then
   return
 end
 local is_uppercase = false  -- TODO
 self:apply_text_case_inner(inlines, text_case, false, is_uppercase)
end

local function string_contains_word(str)
 return string.match(str, "%w") ~= nil
end

local function inline_contains_word(inline)
 if inline._type == "PlainText" then
   return string_contains_word(inline.value)
 elseif inline.inlines then
   for _, el in ipairs(inline.inlines) do
     if inline_contains_word(el) then
       return true
     end
   end
 end
 return false
end

function OutputFormat:apply_text_case_inner(inlines, text_case, seen_one, is_uppercase)
 for i, inline in ipairs(inlines) do
   if seen_one and text_case == "capitalize-first" then
     break
   end
   local is_last = (i == #inlines)
   if inline._type == "PlainText" then
     inline.value = self:transform_case(inline.value, text_case, seen_one, is_last, is_uppercase);
     seen_one = seen_one or string_contains_word(inline.value)

   elseif inline._type == "NoCase" or
       inline._type == "NoDecor" or
       inline._type == "Code" or
       inline._type == "MathML" or
       inline._type == "MathTeX" or
       (inline._type == "Formatted" and inline.formatting["font-variant"] == "small-caps") or
       (inline._type == "Formatted" and inline.formatting["vertical-align"] == "sup") or
       (inline._type == "Formatted" and inline.formatting["vertical-align"] == "sub") then
     seen_one = seen_one or inline_contains_word(inline)

   elseif inline._type == "Formatted" or inline._type == "Quoted"
       or inline._type == "CiteInline" or inline._type == "UndefinedCite" then
     seen_one = self:apply_text_case_inner(inline.inlines, text_case, seen_one, is_uppercase) or seen_one

   end
 end
 return seen_one
end

local function transform_lowercase(str)
 return unicode.lower(str)
end

local function transform_uppercase(str)
 -- TODO: locale specific uppercase: textcase_LocaleUnicode.txt
 return unicode.upper(str)
end

---@param str string
---@param is_first boolean
---@param transform function
---@return string
local function transform_first_word(str, is_first, transform)
 if is_first then
   local segments = unicode.split_word_bounds(str)
   for i, segment in ipairs(segments) do
     -- bugreports_ThesisUniversityAppearsTwice.txt: "Ph.D"
     if uni_utf8.match(segment, "%a") then
       segments[i] = transform(segment)
       break
     end
   end
   str = table.concat(segments)
 end
 return str
end


local SegmentType = {
 Word = 1,
 Puctuation = 2,
 EndingPunctuation = 3,  -- "?" and "!" excluding "." Do we need a sentence break?
 Colon = 4,  -- Including em-dash
 Other = 0,
}

---@param str string
---@param seen_one boolean
---@param is_last_inline boolean
---@param transform function
---@return string
local function transform_each_word(str, seen_one, is_last_inline, transform)
 local segments = unicode.split_word_bounds(str)

 local segment_type_list = {}
 local last_word_idx
 for i, segment in ipairs(segments) do
   segment_type_list[i] = SegmentType.Other

   -- Do not use isalnum(): "can't"
   if uni_utf8.match(segment, "%w") then
     segment_type_list[i] = SegmentType.Word
     last_word_idx = i

   elseif uni_utf8.match(segment, "%p") then
     segment_type_list[i] = SegmentType.Puctuation
     -- In the case of `Form ({MMPI-2-RF}): Technical Manual`, use `endswith()`.
     if util.endswith(segment, "!") or util.endswith(segment, "?") then
       segment_type_list[i] = SegmentType.EndingPunctuation
       -- elseif segment == ":" or segment == "—" then
     elseif util.endswith(segment, ":") then
       -- Em dash is not taken into consideration, see "Stability—with Job" in `textcase_TitleWithEmDash.txt`
       segment_type_list[i] = SegmentType.Colon
     end
   end
 end

 local sentence_begin = not seen_one
 local after_colon = false

 for i, segment in ipairs(segments) do
   if segment_type_list[i] == SegmentType.Word then
     local is_first_word = sentence_begin
     local is_last_word = segment_type_list[i + 1] == SegmentType.EndingPunctuation
         or (is_last_inline and i == last_word_idx)
     -- See "Pro-Environmental" in `textcase_StopWordBeforeHyphen.txt`
     -- but not "Out-of-Fashion" in `textcase_TitleCaseWithHyphens.txt`.
     local ignore_stop_word = segments[i + 1] == "-" and segments[i - 1] ~= "-"

     -- See "07-x" in `textcase_LastChar.txt`
     if not (segments[i - 1] == "-" and unicode.len(segment) == 1) then
       segments[i] = transform(segment, is_first_word, after_colon, is_last_word, ignore_stop_word)

     end

     sentence_begin = false
     after_colon = false

   elseif segment_type_list[i] == SegmentType.EndingPunctuation then
     sentence_begin = true

   elseif segment_type_list[i] == SegmentType.Colon then
     after_colon = true

   end
 end
 return table.concat(segments)
end

---@param word string
---@return string
local function transform_capitalize_word_if_lower(word)
 if unicode.islower(word) then
   local res = unicode.capitalize(word)
   return res
 else
   return word
 end
end

local function title_case_word(word, is_first, after_end_punct, is_last, ignore_stop_word)
 -- Entirely non-English
 -- e.g. "β" in "β-Carotine"
 -- TODO: two-word cases like "due to"
 local res
 if (is_first or is_last or after_end_punct or ignore_stop_word or not util.stop_words[word])
     and string.match(word, "%a") and unicode.islower(word) then
   res = unicode.capitalize(word)
 else
   res = word
 end
 return res
end

local function transform_lowercase_if_capitalize(word, is_first, after_end_punct, is_last, is_stop_word)
 if not (is_first or after_end_punct) then
   local is_capitalize_word = false
   local lower_first = string.gsub(word, utf8.charpattern, unicode.lower, 1)
   if unicode.islower(lower_first) then
     return lower_first
   else
     return word
   end
 else
   return word
 end
end

function OutputFormat:transform_case(str, text_case, seen_one, is_last, is_uppercase)
 local res = str
 if text_case == "lowercase" then
   res = transform_lowercase(str)
 elseif text_case == "uppercase" then
   res = transform_uppercase(str)
 elseif text_case == "capitalize-first" then
   res = transform_first_word(str, not seen_one, transform_capitalize_word_if_lower)
 elseif text_case == "capitalize-all" then
   res = transform_each_word(str, false, true, transform_capitalize_word_if_lower)
 elseif text_case == "sentence" then
   -- TODO: if uppercase convert all to lowercase
   res = transform_first_word(str, not seen_one, transform_capitalize_word_if_lower)
 elseif text_case == "title" then
   -- TODO: if uppercase convert all to lowercase
   res = transform_each_word(str, seen_one, is_last, title_case_word)
 elseif text_case == "sentence-strong" then
   -- Conversion for BibTeX title fields to sentence case
   -- TODO: if uppercase convert all to lowercase
   res = transform_each_word(str, seen_one, is_last, transform_lowercase_if_capitalize)
   res = transform_first_word(res, not seen_one, transform_capitalize_word_if_lower)
 end
 return res
end

function OutputFormat:affixed(inlines, affixes)
 if affixes and affixes.prefix then
   table.insert(inlines, 1, PlainText:new(affixes.prefix))
 end
 if affixes and affixes.suffix then
   table.insert(inlines, PlainText:new(affixes.suffix))
 end
 return inlines
end

---@param inlines InlineElement[]
---@param affixes table
---@param localized_quotes LocalizedQuotes
---@return InlineElement[]
function OutputFormat:affixed_quoted(inlines, affixes, localized_quotes)
 inlines = util.clone(inlines)
 if localized_quotes then
   inlines = {Quoted:new(inlines, localized_quotes)}
 end
 if affixes and affixes.prefix and affixes.prefix ~= "" then
   table.insert(inlines, 1, PlainText:new(affixes.prefix))
 end
 if affixes and affixes.suffix and affixes.suffix ~= "" then
   table.insert(inlines, PlainText:new(affixes.suffix))
 end
 return inlines
end

function OutputFormat:with_display(nodes, display)
 if display then
   return {Div:new(nodes, display)}
 else
   return nodes
 end
end

---@param inlines InlineElement[]
---@param context Context
function OutputFormat:output(inlines, context)
 self:flip_flop_inlines(inlines)

 self:move_punctuation(inlines)

 return self:write_inlines(inlines, context)
end

---@param inlines InlineElement[]
---@param context Context
---@return string?
function OutputFormat:output_bibliography_entry(inlines, context)
 self:flip_flop_inlines(inlines)
 self:move_punctuation(inlines)
 -- TODO:
 -- if self.format == "html" then
 -- elseif self.format == "latex" then
 -- end
 local res = self:write_inlines(inlines, context)
 local markup = self.markups["@bibliography/entry"]
 if type(markup) == "string" then
   res = string.format(markup, res)
 elseif type(markup) == "function" then
   res = markup(res, context)
 end
 return res
end

---@param inlines InlineElement[]
function OutputFormat:flip_flop_inlines(inlines)
 ---@class FlipFlopState
 local flip_flop_state = {
   ["font-style"] = "normal",
   ["font-variant"] = "normal",
   ["font-weight"] = "normal",
   ["text-decoration"] = "none",
   ["vertical-alignment"] = "baseline",
   in_quotes = false,
   inner_quotes = false,
 }
 self:flip_flop(inlines, flip_flop_state)
end

---@param inlines InlineElement[]
---@param state FlipFlopState
function OutputFormat:flip_flop(inlines, state)
 for i, inline in ipairs(inlines) do
   if inline._type == "Micro" then
     self:flip_flop_micro_inlines(inline.inlines, state)

   elseif inline._type == "Formatted" then
     local new_state = util.clone(state)
     local formatting = inline.formatting

     for _, attribute in ipairs({"font-style", "font-variant", "font-weight"}) do
       local value = formatting[attribute]
       if value then
         if value == state[attribute] then
           if value == "normal" then
             formatting[attribute] = nil
             -- Formatting outside Micro is not reset to "normal".
             -- else
             --   formatting[attribute] = "normal"
           end
         end
         new_state[attribute] = value
       end
     end
     self:flip_flop(inline.inlines, new_state)

   elseif inline._type == "Quoted" then
     ---@cast inline Quoted
     if state.in_quotes then
       inline.is_inner = not state.inner_quotes
     end
     local new_state = util.clone(state)
     new_state.in_quotes = true
     new_state.inner_quotes = inline.is_inner
     self:flip_flop(inline.inlines, new_state)

   elseif inline._type == "NoDecor" then
     local new_state = {
       ["font-style"] = "normal",
       ["font-variant"] = "normal",
       ["font-weight"] = "normal",
       ["text-decoration"] = "none",
     }
     self:flip_flop(inline.inlines, new_state)
     for attr, value in pairs(new_state) do
       if value and state[attr] ~= value then
         if not inline.formatting then
           inline._type = "Formatted"
           inline.formatting = {}
         end
         inline.formatting[attr] = value
       end
     end

   elseif inline._type == "Code" or
       inline._type == "MathML" or
       inline._type == "MathTeX" then

   elseif inline.inlines then  -- Div, ...
     self:flip_flop(inline.inlines, state)
   end
 end
end

---@param inlines InlineElement[]
---@param state FlipFlopState
function OutputFormat:flip_flop_micro_inlines(inlines, state)
 for i, inline in ipairs(inlines) do
   if inline._type == "Micro" then
     self:flip_flop_micro_inlines(inline.inlines, state)

   elseif inline._type == "Formatted" then
     local new_state = util.clone(state)
     local formatting = inline.formatting

     for _, attribute in ipairs({"font-style", "font-variant", "font-weight"}) do
       local value = formatting[attribute]
       if value then
         if value == state[attribute] then
           if value == "normal" then
             formatting[attribute] = nil
           else
             -- Formatting inside Micro is reset to "normal".
             formatting[attribute] = "normal"
             value = "normal"
           end
         end
         new_state[attribute] = value
       end
     end
     self:flip_flop_micro_inlines(inline.inlines, new_state)

   elseif inline._type == "Quoted" then
     ---@cast inline Quoted
     if state.in_quotes then
       inline.is_inner = not state.inner_quotes
     end
     local new_state = util.clone(state)
     new_state.in_quotes = true
     new_state.inner_quotes = inline.is_inner
     self:flip_flop_micro_inlines(inline.inlines, new_state)

   elseif inline._type == "NoDecor" then
     local new_state = {
       ["font-style"] = "normal",
       ["font-variant"] = "normal",
       ["font-weight"] = "normal",
       ["text-decoration"] = "none",
     }
     self:flip_flop_micro_inlines(inline.inlines, new_state)
     for attr, value in pairs(new_state) do
       if value and state[attr] ~= value then
         if not inline.formatting then
           inline._type = "Formatted"
           inline.formatting = {}
         end
         inline.formatting[attr] = value
       end
     end

   elseif inline._type == "Code" or
       inline._type == "MathML" or
       inline._type == "MathTeX" then

   elseif inline.inlines then  -- Div, ...
     self:flip_flop_micro_inlines(inline.inlines, state)
   end
 end
end

---@param inline InlineElement
---@return InlineElement?
local function find_left(inline)
 if inline._type == "PlainText" then
   return inline
   -- elseif inline._type == "Micro" then
   --   return nil
 elseif inline.inlines and #inline.inlines > 0 and inline._type ~= "Quoted" then
   return find_left(inline.inlines[1])
 else
   return nil
 end
end

local function find_right(inline)
 if inline._type == "PlainText" then
   return inline
   -- elseif inline._type == "Micro" then
   --   return nil
 elseif inline.inlines and #inline.inlines > 0 and inline._type ~= "Quoted" then
   return find_right(inline.inlines[#inline.inlines])
 else
   return nil
 end
end

local function find_right_in_quoted(inline)
 if inline._type == "PlainText" then
   return inline
   -- elseif inline._type == "Micro" then
   --   return nil
 elseif inline.inlines and #inline.inlines > 0 then
   return find_right_in_quoted(inline.inlines[#inline.inlines])
 else
   return nil
 end
end

--- "'Foo,' bar" => ,
---@param inline InlineElement
---@return boolean
local function find_right_quoted(inline)
 if inline._type == "Quoted" and #inline.inlines > 0 then
   ---@cast inline Quoted
   return find_right_in_quoted(inline.inlines[#inline.inlines]), inline.quotes.punctuation_in_quote
   -- elseif inline._type == "Micro" then
   --   return nil
 elseif inline.inlines and #inline.inlines > 0 then
   return find_right_quoted(inline.inlines[#inline.inlines])
 else
   return nil, false
 end
end

local function smash_string_push(first, second)
 local first_char = string.sub(first.value, -1)
 local second_char = string.sub(second.value, 1, 1)

 local punct_map = output_module.quote_punctuation_map
 if second_char == " " and (first_char == " " or
       util.endswith(first.value, util.unicode["no-break space"])) then
   second.value = string.sub(second.value, 2)
 elseif punct_map[first_char] then
   if first_char == second_char then
     second.value = string.sub(second.value, 2)
   else
     local combined = punct_map[first_char][second_char]
     if combined and #combined == 1 then
       second.value = string.sub(second.value, 2)
       first.value = string.sub(first.value, 1, -2) .. combined
     end
   end
 end
end

local function smash_just_punc(first, second)
 first = find_right(first)  -- PlainText
 second = find_left(second)  -- PlainText
 if first and second then
   local first_char = string.sub(first.value, -1)
   local second_char = string.sub(second.value, 1, 1)

   local punct_map = output_module.quote_punctuation_map
   if second_char == " " and (first_char == " " or
         util.endswith(first.value, util.unicode["no-break space"])) then
     second.value = string.sub(second.value, 2)
     return true
   elseif punct_map[first_char] then
     if first_char == second_char then
       second.value = string.sub(second.value, 2)
       return true
     else
       local combined = punct_map[first_char][second_char]
       if combined and #combined == 1 then
         second.value = string.sub(second.value, 2)
         first.value = string.sub(first.value, 1, -2) .. combined
         return true
       end
     end
   end
 else
   return false
 end
end

local function normalise_text_elements(inlines)
 -- 1. Merge punctuations: "?." => "?"
 -- 2. Merge spaces: "  " => " "
 local idx = 1
 while idx < #inlines do
   local first = inlines[idx]
   local second = inlines[idx + 1]

   if first._type == "PlainText" and second._type == "PlainText" then
     smash_string_push(first, second)
     first.value = first.value .. second.value
     table.remove(inlines, idx + 1)

   elseif first._type == "Micro" and second._type == "PlainText" then
     local success = smash_just_punc(first, second)
     if success then
       if second.value == "" then
         table.remove(inlines, idx + 1)
       end
     else
       idx = idx + 1
     end

   elseif (first._type == "Formatted" or first._type == "CiteInline"
         or first._type == "UndefinedCite") and second._type == "PlainText" then
     local success = smash_just_punc(first, second)
     if success then
       if second.value == "" then
         table.remove(inlines, idx + 1)
       end
     else
       idx = idx + 1
     end

   else
     idx = idx + 1
   end
 end

end

local function move_in_quotes(first, second)
 local first_char = string.sub(first.value, -1)
 local second_char = string.sub(second.value, 1, 1)
 local success = false
 if output_module.move_in_puncts[second_char] then
   if first_char == second_char then
     second.value = string.sub(second.value, 2)
     success = true
   elseif output_module.quote_punctuation_map[first_char] then
     local combined = output_module.quote_punctuation_map[first_char][second_char]
     first.value = string.sub(first.value, 1, -2) .. combined
     second.value = string.sub(second.value, 2)
     success = true
   else
     first.value = first.value .. second_char
     second.value = string.sub(second.value, 2)
     success = true
   end
 end
 return success
end

local function move_out_quotes(first, second)
 local first_char = string.sub(first.value, -1)
 local second_char = string.sub(second.value, 1, 1)
 local success = false
 if output_module.move_out_puncts[first_char] then
   if first_char == second_char then
     first.value = string.sub(first.value, 1, -2)
     success = true
   elseif output_module.quote_punctuation_map[second_char] then
     local combined = output_module.quote_punctuation_map[first_char][second_char]
     first.value = string.sub(first.value, 1, -2)
     second.value = combined .. string.sub(second.value, 2)
     success = true
   else
     first.value = string.sub(first.value, 1, -2)
     second.value = first_char .. second.value
     success = true
   end
 end
 return success
end

---@param inlines InlineElement[]
local function move_around_quote(inlines)
 local idx = 1

 while idx < #inlines do
   -- Move punctuation into quotes as needed
   local first, punctuation_in_quote = find_right_quoted(inlines[idx])

   local second = find_left(inlines[idx + 1])
   local success = false
   if first and second then
     if punctuation_in_quote then
       success = move_in_quotes(first, second)
     else
       success = move_out_quotes(first, second)
     end
     if not success then
       idx = idx + 1
     end
   else
     idx = idx + 1
   end
 end
end

---@param inlines InlineElement[]
---@param punctuation_in_quote boolean?
function OutputFormat:move_punctuation(inlines, punctuation_in_quote)
 -- Merge punctuations
 normalise_text_elements(inlines)

 move_around_quote(inlines)

 for _, inline in ipairs(inlines) do
   if inline._type == "Quoted" or inline._type == "Formatted" or
       inline._type == "Div" or inline._type == "CiteInline"
       or inline._type == "UndefinedCite" then
     self:move_punctuation(inline.inlines)
   end
 end
end

function OutputFormat:write_inlines(inlines, context)
 local res = ""
 for _, inline in ipairs(inlines) do
   res = res .. self:write_inline(inline, context)
 end
 return res
end

function OutputFormat:write_inline(inline, context)
 if inline.value then
   return self:write_escaped(inline.value, context)
 elseif inline.inlines then
   return self:write_inlines(inline.inlines, context)
 end
 return ""
end

function OutputFormat:write_escaped(str, context)
 return str
end


---@class Markup: OutputFormat
local Markup = OutputFormat:new()

function Markup:write_inline(inline, context)
 -- if not context then
 --   print(debug.traceback())
 --   error('stop')
 -- end
 if type(inline) == "string" then
   -- Should not happen
   return self:write_escaped(inline, context)

 elseif type(inline) == "table" then
   if inline._type == "PlainText" then
     return self:write_escaped(inline.value, context)

   elseif inline._type == "InlineElement" then
     return self:write_inlines(inline.inlines, context)

   elseif inline._type == "Formatted" then
     return self:write_formatted(inline, context)

   elseif inline._type == "Quoted" then
     return self:write_quoted(inline, context)

   elseif inline._type == "Div" then
     return self:write_display(inline, context)

   elseif inline._type == "Linked" then
     return self:write_link(inline, context)

   elseif inline._type == "CiteInline" then
     return self:write_cite(inline, context)

   elseif inline._type == "UndefinedCite" then
     return self:write_undefined_cite(inline, context)

   elseif inline._type == "Code" then
     return self:write_code(inline, context)

   elseif inline._type == "MathML" then
     return self:write_math_ml(inline, context)

   elseif inline._type == "MathTeX" then
     return self:write_math_tex(inline, context)

   elseif inline._type == "NoCase" then
     return self:write_nocase(inline, context)

   elseif inline._type == "NoDecor" then
     return self:write_nodecor(inline, context)

   else
     return self:write_inlines(inline.inlines, context)
   end
 end
 return ""
end

function Markup:write_formatted(inline, context)
 return self:write_inlines(inline.inlines, context)
end

---@param inline Quoted
---@param context Context
---@return string
function Markup:write_quoted(inline, context)
 local res = self:write_inlines(inline.inlines, context)
 local quotes = inline.quotes
 if inline.is_inner then
   return quotes.inner_open .. res .. quotes.inner_close
 else
   return quotes.outer_open .. res .. quotes.outer_close
 end
end

function Markup:write_display(inline, context)
 return self:write_inlines(inline.inlines, context)
end

function Markup:write_link(inline, context)
 return self:write_escaped(inline.value, context)
end

function Markup:write_cite(inline, context)
 return self:write_inlines(inline.inlines, context)
end

function Markup:write_undefined_cite(inline, context)
 local bold_inline = Formatted:new({PlainText:new(inline.cite_item.id)}, {["font-weight"] = "bold"})
 return self:write_formatted(bold_inline, context)
end

function Markup:write_code(inline, context)
 return inline.value
end

function Markup:write_math_ml(inline, context)
 return inline.value
end

function Markup:write_math_tex(inline, context)
 return inline.value
end

function Markup:write_nocase(inline, context)
 return self:write_inlines(inline.inlines, context)
end

function Markup:write_nodecor(inline, context)
 return self:write_inlines(inline.inlines, context)
end


local LatexWriter = Markup:new()

LatexWriter.markups = {
 ["bibstart"] = function (engine)
   return string.format("\\begin{thebibliography}{%s}\n", engine.registry.widest_label)
 end,
 ["bibend"] = "\\end{thebibliography}",
 ["@font-style/normal"] = "{\\normalshape %s}",
 ["@font-style/italic"] = "\\textit{%s}",
 ["@font-style/oblique"] = "\\textsl{%s}",
 ["@font-variant/normal"] = "{\\normalshape %s}",
 ["@font-variant/small-caps"] = "\\textsc{%s}",
 ["@font-weight/normal"] = "{\\fontseries{m}\\selectfont %s}",
 ["@font-weight/bold"] = "\\textbf{%s}",
 ["@font-weight/light"] = "{\\fontseries{l}\\selectfont %s}",
 ["@text-decoration/none"] = false,
 ["@text-decoration/underline"] = "\\underline{%s}",
 ["@vertical-align/sup"] = "\\textsuperscript{%s}",
 ["@vertical-align/sub"] = "\\textsubscript{%s}",
 ["@vertical-align/baseline"] = false,
 ["@cite/entry"] = false,
 ["@bibliography/entry"] = function (str, context)
   if not string.match(str, "\\bibitem") then
     str = "\\bibitem{" .. context.id .. "}\n" .. str
   end
   str = str .. "\n"
   return str
 end,
 ["@display/block"] = "\\cslblock{%s}\n\n",
 -- ["@display/left-margin"] = '\n    <div class="csl-left-margin">%s</div>',
 ["@display/right-inline"] = "%s",
 ["@display/indent"] = "\n\n%s",
}

local latex_escape_table = {
 ["\\"] = "\\textbackslash ",
 ["{"] = "\\{",
 ["}"] = "\\}",
 ["$"] = "\\$",
 ["&"] = "\\&",
 ["#"] = "\\#",
 ["^"] = "\\^",
 ["_"] = "\\_",
 ["%"] = "\\%",
 ["~"] = "\\~",
}

---@param str string
---@param context Context
---@return string
function LatexWriter:write_escaped(str, context)
 -- TeXbook, p. 38
 str = str:gsub("[\\{}$&#^_%%~]", latex_escape_table)
 str = str:gsub(util.unicode["em space"], "\\quad ")
 str = str:gsub(util.unicode["no-break space"], "~")
 for char, sub in pairs(util.superscripts) do
   str = string.gsub(str, char, "\\textsuperscript{" .. sub .. "}")
 end
 return str
end

function LatexWriter:write_formatted(inline, context)
 local res = self:write_inlines(inline.inlines, context)
 for _, key in ipairs({"font-style", "font-variant", "font-weight", "text-decoration", "vertical-align"}) do
   local value = inline.formatting[key]
   if value then
     key = "@" .. key .. "/" .. value
     local format_str = self.markups[key]
     if format_str then
       res = string.format(format_str, res)
     end
   end
 end
 return res
end

function LatexWriter:write_display(inline, context)
 if inline.div == "left-margin" then
   local plainter_text_writer = output_module.PlainTextWriter:new()
   local str = plainter_text_writer:write_inline(inline, context)
   local len = utf8.len(str)
   if len > context.engine.registry.maxoffset then
     context.engine.registry.maxoffset = len
     context.engine.registry.widest_label = str
   end
 end

 local res = self:write_inlines(inline.inlines, context)
 if inline.div == "left-margin" then
   if string.match(res, "%]") then
     res = "{" .. res .. "}"
   end
   res = string.format("\\bibitem[%s]{%s}\n", res, context.id)

 else
   local key = string.format("@display/%s", inline.div)
   if inline.div == "right-inline" then
     -- Strip trailing spaces
     -- variables_ContainerTitleShort.txt
     res = string.gsub(res, "%s+$", "")
   end
   local format_str = self.markups[key]
   if format_str then
     res = string.format(format_str, res)
   else
     util.error("Unknown display type: " .. inline.div)
   end
 end
 return res
end

function LatexWriter:write_link(inline, context)
 if inline.href == inline.value then
   -- URL
   return string.format("\\url{%s}", inline.value)
 elseif context.engine.opt.wrap_url_and_doi then
   return string.format("\\href{%s}{%s}", inline.href, self:write_escaped(inline.value, context))
 else
   return self:write_escaped(inline.value, context)
 end
end

function LatexWriter:write_cite(inline, context)
 local str = self:write_inlines(inline.inlines, context)
 if context.engine.opt.citation_link then
   str = string.format("\\cslcite{%s}{%s}", inline.cite_item.id, str)
 end
 return str
end

function LatexWriter:write_undefined_cite(inline, context)
 return string.format("\\cslundefinedcite{%s}", inline.cite_item.id)
end

function LatexWriter:write_code(inline, context)
 return inline.value
end

function LatexWriter:write_math_ml(inline, context)
 util.error("MathML is not supported in LaTeX output.")
 return ""
end

function LatexWriter:write_math_tex(inline, context)
 return string.format("$%s$", inline.value)
end


local HtmlWriter = Markup:new()

HtmlWriter.markups = {
 ["bibstart"] = "<div class=\"csl-bib-body\">\n",
 ["bibend"] = "</div>",
 ["@font-style/italic"] = "<i>%s</i>",
 ["@font-style/oblique"] = "<em>%s</em>",
 ["@font-style/normal"] = '<span style="font-style:normal;">%s</span>',
 ["@font-variant/small-caps"] = '<span style="font-variant:small-caps;">%s</span>',
 ["@font-variant/normal"] = '<span style="font-variant:normal;">%s</span>',
 ["@font-weight/bold"] = "<b>%s</b>",
 ["@font-weight/normal"] = '<span style="font-weight:normal;">%s</span>',
 ["@font-weight/light"] = false,
 ["@text-decoration/none"] = '<span style="text-decoration:none;">%s</span>',
 ["@text-decoration/underline"] = '<span style="text-decoration:underline;">%s</span>',
 ["@vertical-align/sup"] = "^%s",
 ["@vertical-align/sub"] = "_%s",
 ["@vertical-align/baseline"] = '<span style="baseline">%s</span>',
 ["@cite/entry"] = nil,
 ["@bibliography/entry"] = "<div class=\"csl-entry\">%s</div>\n",
 ["@display/block"] = '\n\n    <div class="csl-block">%s</div>\n',
 ["@display/left-margin"] = '\n    <div class="csl-left-margin">%s</div>',
 ["@display/right-inline"] = '<div class="csl-right-inline">%s</div>\n  ',
 ["@display/indent"] = '<div class="csl-indent">%s</div>\n  ',
}

function HtmlWriter:write_escaped(str, context)
 str = string.gsub(str, "%&", "&#38;")
 str = string.gsub(str, "<", "&#60;")
 str = string.gsub(str, ">", "&#62;")
 for char, sub in pairs(util.superscripts) do
   str = string.gsub(str, char, "^{" .. sub .. "}")
 end
 return str
end

function HtmlWriter:write_formatted(inline, context)
 local res = self:write_inlines(inline.inlines, context)
 for _, key in ipairs({"font-style", "font-variant", "font-weight", "text-decoration", "vertical-align"}) do
   local value = inline.formatting[key]
   if value then
     key = "@" .. key .. "/" .. value
     local format_str = self.markups[key]
     if format_str then
       res = string.format(format_str, res)
     end
   end
 end
 return res
end

function HtmlWriter:write_display(inline, context)
 if inline.div == "left-margin" then
   local plainter_text_writer = output_module.PlainTextWriter:new()
   local str = plainter_text_writer:write_inline(inline, context)
   --TODO: width of CJK characters
   local len = utf8.len(str)
   if len > context.engine.registry.maxoffset then
     context.engine.registry.maxoffset = len
     context.engine.registry.widest_label = str
   end
 end

 if #inline.inlines == 0 then
   return ""
 end
 local res = self:write_inlines(inline.inlines, context)
 local key = string.format("@display/%s", inline.div)
 if inline.div == "right-inline" then
   -- Strip trailing spaces
   -- variables_ContainerTitleShort.txt
   res = string.gsub(res, "%s+$", "")
 end
 local format_str = self.markups[key]
 if format_str then
   res = string.format(format_str, res)
 end
 return res
end

function HtmlWriter:write_link(inline, context)
 -- if not context then
 --   print(debug.traceback())
 -- end
 local content = self:write_escaped(inline.value, context)
 if context.engine.opt.wrap_url_and_doi then
   local href = self:write_escaped(inline.href, context)
   return string.format('<a href="%s">%s</a>', href, content)
 else
   return content
 end
end

function HtmlWriter:write_code(inline, context)
 return string.format("<code>%s</code>", inline.value)
end

function HtmlWriter:write_math_ml(inline, context)
 return string.format('<math xmlns="http://www.w3.org/1998/Math/MathML">%s</math>', inline.value)
end

function HtmlWriter:write_math_tex(inline, context)
 return string.format("<code>$%s$</code>", self:write_escaped(inline.value, context))
end


local PlainTextWriter = Markup:new()

PlainTextWriter.markups = {}

function PlainTextWriter:write_escaped(str, context)
 return str
end

function PlainTextWriter:write_formatted(inline, context)
 return self:write_inlines(inline.inlines, context)
end

function PlainTextWriter:write_display(inline, context)
 return self:write_inlines(inline.inlines, context)
end


-- Omit formatting and quotes
local SortStringFormat = OutputFormat:new()

function SortStringFormat:output(inlines, context)
 -- self:flip_flop_inlines(inlines)
 -- self:move_punctuation(inlines)
 return self:write_inlines(inlines, context)
end

function SortStringFormat:write_escaped(str, context)
 -- sort_Quotes.txt
 str = string.gsub(str, ",", "")
 return str
end


-- Omit formatting and quotes

---@class DisamStringFormat: OutputFormat
local DisamStringFormat = OutputFormat:new()

function DisamStringFormat:output(inlines, context)
 -- self:flip_flop_inlines(inlines)
 -- self:move_punctuation(inlines)
 return self:write_inlines(inlines, context)
end

function DisamStringFormat:flatten_ir(ir)
 if self.group_var == GroupVar.Missing then
   return {}
 end
 local inlines
 if ir._type == "SeqIr" or ir._type == "NameIr" then
   if ir._element and ir._element.variable == "accessed" then
     -- Accessed isn't really part of a reference -- it doesn't help disambiguating one from
     -- another. So we will ignore it. Works for, e.g., date_YearSuffixImplicitWithNoDate.txt
     inlines = {}
   else
     inlines = self:flatten_seq_ir(ir)
   end
 elseif ir._type == "YearSuffix" then
   -- Don't include year-suffix in disambiguation
   inlines = {}
 else
   inlines = self:affixed_quoted(ir.inlines, ir.affixes, ir.quotes);
   inlines = self:with_display(inlines, ir.display);
 end
 return inlines
end

function DisamStringFormat:flatten_seq_ir(ir)
 -- if not ir.children then
 --   print(debug.traceback())
 -- end
 if #ir.children == 0 then
   return {}
 end
 local inlines_list = {}
 for _, child in ipairs(ir.children) do
   if child.group_var == GroupVar.Important or child.group_var == GroupVar.Plain then
     -- and not child.collapse_suppressed
     -- Suppressed irs are stil kept in the DisamStringFormat
     table.insert(inlines_list, self:flatten_ir(child))
   end
 end

 local inlines = self:group(inlines_list, ir.delimiter, ir.formatting)
 -- assert ir.quotes == localized quotes
 inlines = self:affixed_quoted(inlines, ir.affixes, ir.quotes);
 inlines = self:with_display(inlines, ir.display);

 -- -- A citation layout
 -- if ir._element_name == "layout" and ir.cite_item then
 --   inlines = {CiteInline:new(inlines, ir.cite_item)}
 -- end

 return inlines
end


local PseudoHtml = HtmlWriter:new()

function PseudoHtml:write_escaped(str, context)
 -- str = string.gsub(str, "%&", "&#38;")
 -- str = string.gsub(str, "<", "&#60;")
 -- str = string.gsub(str, ">", "&#62;")
 -- for char, sub in pairs(util.superscripts) do
 --   str = string.gsub(str, char, "^{" .. sub .. "}")
 -- end
 return str
end

function PseudoHtml:write_math_ml(inline, context)
 return string.format("<math>%s</math>", inline.value)
end

function PseudoHtml:write_math_tex(inline, context)
 return string.format("<math-tex>%s</math-tex>", inline.value)
end

function PseudoHtml:write_nocase(inline, context)
 local str = self:write_inlines(inline.inlines, context)
 return string.format('<span class="nocase">%s</span>', str)
end


function InlineElement.has_space(inlines)
 local str = DisamStringFormat:output(inlines)
 if not str then
   return false
 end
 if string.match(util.strip(str), "%s") then
   return true
 else
   return false
 end
end

output_module.move_in_puncts = {
 ["."] = true,
 ["!"] = true,
 ["?"] = true,
 [","] = true,
}

output_module.move_out_puncts = {
 [","] = true,
 [";"] = true,
 [":"] = true,
}

-- https://github.com/Juris-M/citeproc-js/blob/aa2683f48fe23be459f4ed3be3960e2bb56203f0/src/queue.js#L724
-- Also merge duplicate punctuations.
output_module.quote_punctuation_map = {
 ["!"] = {
   ["."] = "!",
   ["?"] = "!?",
   [":"] = "!",
   [","] = "!,",
   [";"] = "!;",
 },
 ["?"] = {
   ["!"] = "?!",
   ["."] = "?",
   [":"] = "?",
   [","] = "?,",
   [";"] = "?;",
 },
 ["."] = {
   ["!"] = ".!",
   ["?"] = ".?",
   [":"] = ".:",
   [","] = ".,",
   [";"] = ".;",
 },
 [":"] = {
   ["!"] = "!",
   ["?"] = "?",
   ["."] = ":",
   [","] = ":,",
   [";"] = ":;",
 },
 [","] = {
   ["!"] = ",!",
   ["?"] = ",?",
   [":"] = ",:",
   ["."] = ",.",
   [";"] = ",;",
 },
 [";"] = {
   ["!"] = "!",
   ["?"] = "?",
   [":"] = ";",
   [","] = ";,",
   ["."] = ";",
 },
}


output_module.LocalizedQuotes = LocalizedQuotes

output_module.InlineElement = InlineElement
output_module.PlainText = PlainText
output_module.Formatted = Formatted
output_module.Micro = Micro
output_module.Quoted = Quoted
output_module.Linked = Linked
output_module.Div = Div
output_module.CiteInline = CiteInline
output_module.UndefinedCite = UndefinedCite
output_module.Code = Code
output_module.MathTeX = MathTeX
output_module.MathTML = MathML
output_module.NoCase = NoCase
output_module.NoDecor = NoDecor

output_module.OutputFormat = OutputFormat

output_module.Markup = Markup
output_module.LatexWriter = LatexWriter
output_module.HtmlWriter = HtmlWriter
output_module.PlainTextWriter = PlainTextWriter
output_module.DisamStringFormat = DisamStringFormat
output_module.SortStringFormat = SortStringFormat
output_module.PseudoHtml = PseudoHtml

return output_module

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.