djot 0.0.6 → 0.0.7

data/lib/lua/djot/block.lua

@@ -1,807 +0,0 @@
-local inline = require("djot.inline")
-local attributes = require("djot.attributes")
-local match = require("djot.match")
-local make_match, unpack_match = match.make_match, match.unpack_match
-local unpack = unpack or table.unpack
-local find, sub, byte = string.find, string.sub, string.byte
-
-local Container = {}
-
-function Container:new(spec, data)
-  local contents = {}
-  setmetatable(contents, spec)
-  spec.__index = spec
-  if data then
-    for k,v in pairs(data) do
-      contents[k] = v
-    end
-  end
-  return contents
-end
-
-local function get_list_style(marker)
-  if marker == "+" or marker == "-" or marker == "*" or marker == ":" then
-    return marker
-  elseif find(marker, "^[+*-] %[[Xx ]%]") then
-    return "X" -- task list
-  elseif find(marker, "^%[[Xx ]%]") then
-    return "X"
-  elseif find(marker, "^[(]?%d+[).]") then
-    return (marker:gsub("%d+","1"))
-  -- in ambiguous cases we return two values
-  elseif find(marker, "^[(]?[ivxlcdm][).]") then
-    return (marker:gsub("%a+", "a")), (marker:gsub("%a+", "i"))
-  elseif find(marker, "^[(]?[IVXLCDM][).]") then
-    return (marker:gsub("%a+", "A")), (marker:gsub("%a+", "I"))
-  elseif find(marker, "^[(]?%l[).]") then
-    return (marker:gsub("%l", "a"))
-  elseif find(marker, "^[(]?%u[).]") then
-    return (marker:gsub("%u", "A"))
-  elseif find(marker, "^[(]?[ivxlcdm]+[).]") then
-    return (marker:gsub("%a+", "i"))
-  elseif find(marker, "^[(]?[IVXLCDM]+[).]") then
-    return (marker:gsub("%a+", "I"))
-  else
-    assert(false, "Could not identify list style for " .. marker)
-  end
-end
-
-local Parser = {}
-
-function Parser:new(subject, opts)
-  -- ensure the subject ends with a newline character
-  if not subject:find("[\r\n]$") then
-    subject = subject .. "\n"
-  end
-  local state = {
-    subject = subject,
-    indent = 0,
-    startline = nil,
-    starteol = nil,
-    endeol = nil,
-    matches = {},
-    containers = {},
-    pos = 1,
-    last_matched_container = 0,
-    timer = {},
-    warnings = {},
-    opts = opts or {},
-    finished_line = false }
-  setmetatable(state, self)
-  self.__index = self
-  return state
-end
-
--- parameters are start and end position
-function Parser:parse_table_row(sp, ep)
-  local orig_matches = #self.matches  -- so we can rewind
-  local startpos = self.pos
-  self:add_match(sp, sp, "+row")
-  -- skip | and any initial space in the cell:
-  self.pos = find(self.subject, "%S", sp + 1)
-  -- check to see if we have a separator line
-  local seps = {}
-  local p = self.pos
-  local sepfound = false
-  while not sepfound do
-    local sepsp, sepep, left, right, trailing =
-      find(self.subject, "^(%:?)%-%-*(%:?)([ \t]*%|[ \t]*)", p)
-    if sepep then
-      local st = "separator_default"
-      if #left > 0 and #right > 0 then
-        st = "separator_center"
-      elseif #right > 0 then
-        st = "separator_right"
-      elseif #left > 0 then
-        st = "separator_left"
-      end
-      seps[#seps + 1] = {sepsp, sepep - #trailing, st}
-      p = sepep + 1
-      if p == self.starteol then
-        sepfound = true
-        break
-      end
-    else
-      break
-    end
-  end
-  if sepfound then
-    for i=1,#seps do
-      self:add_match(unpack(seps[i]))
-    end
-    self:add_match(self.starteol - 1, self.starteol - 1, "-row")
-    self.pos = self.starteol
-    self.finished_line = true
-    return true
-  end
-  local inline_parser = inline.Parser:new(self.subject, self.opts)
-  self:add_match(sp, sp, "+cell")
-  while self.pos < ep do
-    -- parse a chunk as inline content
-    local _,nextbar = self:find("^[^|\r\n]*|")
-    inline_parser:feed(self.pos, nextbar - 1)
-    if inline_parser:in_verbatim() then
-      -- read the next | as part of verbatim
-      inline_parser:feed(nextbar, nextbar)
-      self.pos = nextbar + 1
-    else
-      self.pos = nextbar + 1  -- skip past the next |
-      -- add a table cell
-      local cell_matches = inline_parser:get_matches()
-      for i=1,#cell_matches do
-        local s,e,ann = unpack_match(cell_matches[i])
-        if i == #cell_matches and ann == "str" then
-          -- strip trailing space
-          while byte(self.subject, e) == 32 and e >= s do
-            e = e - 1
-          end
-        end
-        self:add_match(s,e,ann)
-      end
-      self:add_match(nextbar, nextbar, "-cell")
-      if nextbar < ep then
-        -- reset inline parser state
-        inline_parser = inline.Parser:new(self.subject, self.opts)
-        self:add_match(nextbar, nextbar, "+cell")
-        self.pos = find(self.subject, "%S", self.pos)
-      end
-    end
-  end
-  if inline_parser:in_verbatim() then
-    -- rewind, this is not a valid table row
-    self.pos = startpos
-    for i = orig_matches,#self.matches do
-      self.matches[i] = nil
-    end
-    return false
-  else
-    self:add_match(self.pos, self.pos, "-row")
-    self.pos = self.starteol
-    self.finished_line = true
-    return true
-  end
-end
-
-function Parser:specs()
-  return {
-    { name = "para",
-      is_para = true,
-      content = "inline",
-      continue = function()
-        return self:find("^%S")
-      end,
-      open = function(spec)
-        self:add_container(Container:new(spec,
-            { inline_parser = inline.Parser:new(self.subject, self.opts) }))
-        self:add_match(self.pos, self.pos, "+para")
-        return true
-      end,
-      close = function()
-        self:get_inline_matches()
-        self:add_match(self.pos - 1, self.pos - 1, "-para")
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "caption",
-      is_para = false,
-      content = "inline",
-      continue = function()
-        return self:find("^%S")
-      end,
-      open = function(spec)
-        local _, ep = self:find("^%^[ \t]+")
-        if ep then
-          self.pos = ep + 1
-          self:add_container(Container:new(spec,
-            { inline_parser = inline.Parser:new(self.subject, self.opts) }))
-          self:add_match(self.pos, self.pos, "+caption")
-          return true
-        end
-      end,
-      close = function()
-        self:get_inline_matches()
-        self:add_match(self.pos - 1, self.pos - 1, "-caption")
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "blockquote",
-      content = "block",
-      continue = function()
-        if self:find("^%>%s") then
-          self.pos = self.pos + 1
-          return true
-        else
-          return false
-        end
-      end,
-      open = function(spec)
-        if self:find("^%>%s") then
-          self:add_container(Container:new(spec))
-          self:add_match(self.pos, self.pos, "+blockquote")
-          self.pos = self.pos + 1
-          return true
-        end
-      end,
-      close = function()
-        self:add_match(self.pos, self.pos, "-blockquote")
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    -- should go before reference definitions
-    { name = "footnote",
-      content = "block",
-      continue = function(container)
-        if self.indent > container.indent or self:find("^[\r\n]") then
-          return true
-        else
-          return false
-        end
-      end,
-      open = function(spec)
-        local sp, ep, label = self:find("^%[%^([^]]+)%]:%s")
-        if not sp then
-          return nil
-        end
-        -- adding container will close others
-        self:add_container(Container:new(spec, {note_label = label,
-                                                indent = self.indent}))
-        self:add_match(sp, sp, "+footnote")
-        self:add_match(sp + 2, ep - 3, "note_label")
-        self.pos = ep
-        return true
-      end,
-      close = function(_container)
-        self:add_match(self.pos, self.pos, "-footnote")
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    -- should go before list_item_spec
-    { name = "thematic_break",
-      content = nil,
-      continue = function()
-        return false
-      end,
-      open = function(spec)
-        local sp, ep = self:find("^[-*][ \t]*[-*][ \t]*[-*][-* \t]*[\r\n]")
-        if ep then
-          self:add_container(Container:new(spec))
-          self:add_match(sp, ep, "thematic_break")
-          self.pos = ep
-          return true
-        end
-      end,
-      close = function(_container)
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "list_item",
-      content = "block",
-      continue = function(container)
-        if self.indent > container.indent or self:find("^[\r\n]") then
-          return true
-        else
-          return false
-        end
-      end,
-      open = function(spec)
-        local sp, ep = self:find("^[-*+:]%s")
-        if not sp then
-          sp, ep = self:find("^%d+[.)]%s")
-        end
-        if not sp then
-          sp, ep = self:find("^%(%d+%)%s")
-        end
-        if not sp then
-          sp, ep = self:find("^[ivxlcdmIVXLCDM]+[.)]%s")
-        end
-        if not sp then
-          sp, ep = self:find("^%([ivxlcdmIVXLCDM]+%)%s")
-        end
-        if not sp then
-          sp, ep = self:find("^%a[.)]%s")
-        end
-        if not sp then
-          sp, ep = self:find("^%(%a%)%s")
-        end
-        if not sp then
-          return nil
-        end
-        local marker = sub(self.subject, sp, ep - 1)
-        local checkbox = nil
-        if self:find("^[*+-] %[[Xx ]%]%s", sp + 1) then -- task list
-          marker = sub(self.subject, sp, sp + 4)
-          checkbox = sub(self.subject, sp + 3, sp + 3)
-        end
-        -- some items have ambiguous style
-        local styles = {get_list_style(marker)}
-        local data = { styles = styles,
-                       indent = self.indent }
-        -- adding container will close others
-        self:add_container(Container:new(spec, data))
-        local annot = "+list_item"
-        for i=1,#styles do
-          annot = annot .. "[" .. styles[i] .. "]"
-        end
-        self:add_match(sp, ep - 1, annot)
-        self.pos = ep
-        if checkbox then
-          if checkbox == " " then
-            self:add_match(sp + 2, sp + 4, "checkbox_unchecked")
-          else
-            self:add_match(sp + 2, sp + 4, "checkbox_checked")
-          end
-          self.pos = sp + 5
-        end
-        return true
-      end,
-      close = function(_container)
-        self:add_match(self.pos, self.pos, "-list_item")
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "reference_definition",
-      content = nil,
-      continue = function(container)
-        if container.indent >= self.indent then
-          return false
-        end
-        local _, ep, rest = self:find("^(%S+)")
-        if ep then
-          self:add_match(ep - #rest + 1, ep, "reference_value")
-          container.value = rest
-          self.pos = ep + 1
-        end
-        return true
-      end,
-      open = function(spec)
-        local sp, ep, label, rest = self:find("^%[([^]\r\n]*)%]:[ \t]*(%S*)")
-        if sp then
-          self:add_container(Container:new(spec,
-             { key = label,
-               value = rest,
-               indent = self.indent }))
-          self:add_match(sp, sp, "+reference_definition")
-          self:add_match(sp, sp + #label + 1, "reference_key")
-          if #rest > 0 then
-            self:add_match(ep - #rest + 1, ep, "reference_value")
-          end
-          self.pos = ep + 1
-          return true
-        end
-      end,
-      close = function(_container)
-        self:add_match(self.pos, self.pos, "-reference_definition")
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "heading",
-      content = "inline",
-      continue = function(_container)
-        return false
-      end,
-      open = function(spec)
-        local sp, ep = self:find("^#+")
-        if ep and find(self.subject, "^%s", ep + 1) then
-          local level = ep - sp + 1
-          self:add_container(Container:new(spec, {level = level,
-               inline_parser = inline.Parser:new(self.subject, self.opts) }))
-          self:add_match(sp, ep, "+heading")
-          self.pos = ep + 1
-          return true
-        end
-      end,
-      close = function(_container)
-        self:get_inline_matches()
-        local last = self.matches[#self.matches] or self.pos - 1
-        local sp, ep, annot = unpack_match(last)
-        -- handle final ###
-        local endheadingpos = ep
-        local endheadingendpos = ep
-        if annot == "str" then
-          local endheadingstart, _, hashes =
-            find(sub(self.subject, sp, ep), "%s+(#+)$")
-          if hashes then
-            endheadingpos = endheadingpos - #hashes
-            if endheadingstart == 1 then
-              -- remove final str match
-              self.matches[#self.matches] = nil
-            else
-              self.matches[#self.matches] =
-                make_match(sp, sp + (endheadingstart - 2), "str")
-            end
-          end
-        end
-        self:add_match(endheadingpos, endheadingendpos, "-heading")
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "code_block",
-      content = "text",
-      continue = function(container)
-        local char = sub(container.border, 1, 1)
-        local sp, ep, border = self:find("^(" .. container.border ..
-                                 char .. "*)[ \t]*[\r\n]")
-        if ep then
-          container.end_fence_sp = sp
-          container.end_fence_ep = sp + #border - 1
-          self.pos = ep -- before newline
-          self.finished_line = true
-          return false
-        else
-          return true
-        end
-      end,
-      open = function(spec)
-        local sp, ep, border, ws, lang =
-          self:find("^(~~~~*)([ \t]*)(%S*)[ \t]*[\r\n]")
-        if not ep then
-          sp, ep, border, ws, lang =
-            self:find("^(````*)([ \t]*)([^%s`]*)[ \t]*[\r\n]")
-        end
-        if border then
-          local is_raw = find(lang, "^=") and true or false
-          self:add_container(Container:new(spec, {border = border,
-                                                  indent = self.indent }))
-          self:add_match(sp, sp + #border - 1, "+code_block")
-          if #lang > 0 then
-            local langstart = sp + #border + #ws
-            if is_raw then
-              self:add_match(langstart, langstart + #lang - 1, "raw_format")
-            else
-              self:add_match(langstart, langstart + #lang - 1, "code_language")
-            end
-          end
-          self.pos = ep  -- before newline
-          self.finished_line = true
-          return true
-        end
-      end,
-      close = function(container)
-        local sp = container.end_fence_sp or self.pos
-        local ep = container.end_fence_ep or self.pos
-        self:add_match(sp, ep, "-code_block")
-        if sp == ep then
-          self.warnings[#self.warnings + 1] = {self.pos, "Unclosed code block"}
-        end
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "fenced_div",
-      content = "block",
-      continue = function(container)
-        local sp, ep, equals = self:find("^(::::*)[ \t]*[r\n]")
-        if ep and #equals >= container.equals then
-          container.end_fence_sp = sp
-          container.end_fence_ep = sp + #equals - 1
-          self.pos = ep -- before newline
-          return false
-        else
-          return true
-        end
-      end,
-      open = function(spec)
-        local sp, ep1, equals = self:find("^(::::*)[ \t]*")
-        if not ep1 then
-          return false
-        end
-        local clsp, ep = find(self.subject, "^%w*", ep1 + 1)
-        local _, eol = find(self.subject, "^[ \t]*[\r\n]", ep + 1)
-        if eol then
-          self:add_container(Container:new(spec, {equals = #equals}))
-          self:add_match(sp, ep, "+div")
-          if ep > clsp then
-            self:add_match(clsp, ep, "class")
-          end
-          self.pos = eol + 1
-          self.finished_line = true
-          return true
-        end
-      end,
-      close = function(container)
-        local sp = container.end_fence_sp or self.pos
-        local ep = container.end_fence_ep or self.pos
-        -- check to make sure the match is in order
-        self:add_match(sp, ep, "-div")
-        if sp == ep then
-          self.warnings[#self.warnings + 1] = {self.pos, "Unclosed div"}
-        end
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "table",
-      content = "cells",
-      continue = function(_container)
-        local sp, ep = self:find("^|[^\r\n]*|")
-        local eolsp = " *[\r\n]" -- make sure at end of line
-        if sp and eolsp then
-          return self:parse_table_row(sp, ep)
-        end
-      end,
-      open = function(spec)
-        local sp, ep = self:find("^|[^\r\n]*|")
-        local eolsp = " *[\r\n]" -- make sure at end of line
-        if sp and eolsp then
-          self:add_container(Container:new(spec, { columns = 0 }))
-          self:add_match(sp, sp, "+table")
-          if self:parse_table_row(sp, ep) then
-            return true
-          else
-            self.containers[#self.containers] = nil
-            self.matches[#self.matches] = nil  -- remove +table match
-            return false
-          end
-        end
-     end,
-      close = function(_container)
-        self:add_match(self.pos, self.pos, "-table")
-        self.containers[#self.containers] = nil
-      end
-    },
-
-    { name = "attributes",
-      content = "attributes",
-      continue = function(container)
-        if self.indent > container.indent then
-          container.slices[#container.slices + 1] =
-            {self.pos, self.endeol}
-          self.pos = self.starteol
-          return true
-        else
-          return false
-        end
-      end,
-      open = function(spec)
-        if self:find("^%{") then
-          self:add_container(Container:new(spec,
-                             { slices = {{self.pos, self.endeol}},
-                               indent = self.indent }))
-          self.pos = self.starteol
-          return true
-        end
-      end,
-      close = function(container)
-        local attribute_parser = attributes.AttributeParser:new(self.subject)
-        local slices = container.slices
-        local status, finalpos
-        for i=1,#slices do
-          status, finalpos = attribute_parser:feed(unpack(slices[i]))
-          if status ~= 'continue' then
-            break
-          end
-        end
-        -- make sure there's no extra content after the }
-        if status == 'done' and find(self.subject, "^[ \t]*[\r\n]", finalpos + 1) then
-          local attr_matches = attribute_parser:get_matches()
-          self:add_match(slices[1][1], slices[1][1], "+block_attributes")
-          for i=1,#attr_matches do
-            self:add_match(unpack_match(attr_matches[i]))
-          end
-          self:add_match(slices[#slices][2], slices[#slices][2], "-block_attributes")
-        else -- If not, parse it as inlines and add paragraph match
-          container.inline_parser = inline.Parser:new(self.subject, self.opts)
-          self:add_match(slices[1][1], slices[1][1], "+para")
-          for i=1,#slices do
-            container.inline_parser:feed(unpack(slices[i]))
-          end
-          self:get_inline_matches()
-          self:add_match(slices[#slices][2], slices[#slices][2], "-para")
-        end
-        self.containers[#self.containers] = nil
-      end
-    }
-  }
-end
-
-function Parser:get_inline_matches()
-  local matches, warnings =
-    self.containers[#self.containers].inline_parser:get_matches()
-  for i=1,#matches do
-    self.matches[#self.matches + 1] = matches[i]
-  end
-  for i=1,#warnings do
-    self.warnings[#self.warnings + 1] = warnings[i]
-  end
-end
-
-function Parser:find(patt)
-  return find(self.subject, patt, self.pos)
-end
-
-function Parser:add_match(startpos, endpos, annotation)
-  self.matches[#self.matches + 1] = make_match(startpos, endpos, annotation)
-end
-
-function Parser:add_container(container)
-  local last_matched = self.last_matched_container
-  while #self.containers > last_matched or
-         (#self.containers > 0 and
-          self.containers[#self.containers].content ~= "block") do
-    self.containers[#self.containers]:close()
-  end
-  self.containers[#self.containers + 1] = container
-end
-
-function Parser:skip_space()
-  local newpos, _ = find(self.subject, "[^ \t]", self.pos)
-  if newpos then
-    self.indent = newpos - self.startline
-    self.pos = newpos
-  end
-end
-
-function Parser:get_eol()
-  local starteol, endeol = find(self.subject, "[\r]?[\n]", self.pos)
-  if not endeol then
-    starteol, endeol = #self.subject, #self.subject
-  end
-  self.starteol = starteol
-  self.endeol = endeol
-end
-
-function Parser:parse()
-  local specs = self:specs()
-  local para_spec = specs[1]
-  local subjectlen = #self.subject
-  while self.pos <= subjectlen do
-
-    self.indent = 0
-    self.startline = self.pos
-    self.finished_line = false
-    self:get_eol()
-
-    -- check open containers for continuation
-    self.last_matched_container = 0
-    local idx = 0
-    while idx < #self.containers do
-      idx = idx + 1
-      local container = self.containers[idx]
-      -- skip any indentation
-      self:skip_space()
-      if container:continue() then
-        self.last_matched_container = idx
-      else
-        break
-      end
-    end
-
-    -- if we hit a close fence, we can move to next line
-    if self.finished_line then
-      while #self.containers > self.last_matched_container do
-        self.containers[#self.containers]:close()
-      end
-    end
-
-    if not self.finished_line then
-      -- check for new containers
-      self:skip_space()
-      local is_blank = (self.pos == self.starteol)
-
-      local new_starts = false
-      local last_match = self.containers[self.last_matched_container]
-      local check_starts = not is_blank and
-                          (not last_match or last_match.content == "block") and
-                            not self:find("^%a+%s") -- optimization
-      while check_starts do
-        check_starts = false
-        for i=1,#specs do
-          local spec = specs[i]
-          if not spec.is_para then
-            if spec:open() then
-              self.last_matched_container = #self.containers
-              if self.finished_line then
-                check_starts = false
-              else
-                self:skip_space()
-                new_starts = true
-                check_starts = spec.content ~= "text"
-              end
-              break
-            end
-          end
-        end
-      end
-
-      if not self.finished_line then
-        -- handle remaining content
-        self:skip_space()
-
-        is_blank = (self.pos == self.starteol)
-
-        local is_lazy = not is_blank and
-                        not new_starts and
-                        self.last_matched_container < #self.containers and
-                        self.containers[#self.containers].content == 'inline'
-
-        if not is_lazy and
-          self.last_matched_container < #self.containers then
-          while #self.containers > self.last_matched_container do
-            self.containers[#self.containers]:close()
-          end
-        end
-
-        local tip = self.containers[#self.containers]
-
-        -- add para by default if there's text
-        if not tip or tip.content == 'block' then
-          if is_blank then
-            if not new_starts then
-              -- need to track these for tight/loose lists
-              self:add_match(self.pos, self.endeol, "blankline")
-            end
-          else
-            para_spec:open()
-          end
-          tip = self.containers[#self.containers]
-        end
-
-        if tip then
-          if tip.content == "text" then
-            local startpos = self.pos
-            if tip.indent and self.indent > tip.indent then
-              -- get back the leading spaces we gobbled
-              startpos = startpos - (self.indent - tip.indent)
-            end
-            self:add_match(startpos, self.endeol, "str")
-          elseif tip.content == "inline" then
-            if not is_blank then
-              tip.inline_parser:feed(self.pos, self.endeol)
-            end
-          end
-        end
-      end
-    end
-
-    self.pos = self.endeol + 1
-  end
-  self:finish()
-
-end
-
-function Parser:finish()
-  -- close unmatched containers
-  while #self.containers > 0 do
-    self.containers[#self.containers]:close()
-  end
-end
-
-function Parser:get_matches()
-  return self.matches
-end
-
-return { Parser = Parser,
-         Container = Container }
-
-
---[[
-Copyright (C) 2022 John MacFarlane
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-]]