Convert LiveCode styledText array to/from XHTML

StyledText to XHTML Converter

/** 
* \brief Converts a styled text array to XHTML.
*
* \param pStyledTextA The array to convert.
*
* \return XHTML
*/
function ConvertStyledTextToXHTML pStyledTextA
   local theXHTML, theRun, theString
   local theListKey
   local theClosingListTag, theParaClasses, checkForIndent, theIndentLevel
   
   set the wholematches to true
   
   repeat with i = 1 to the number of elements of pStyledTextA
      if pStyledTextA[i] is not an array then next repeat
      
      ## paragraph level formatting stored in pStyledTextA[i]["style"]
      ## textAlign, listStyle, listDepth, listIndent, firstIndent, leftIndent, rightIndent, 
      ## spaceAbove, spaceBelow, tabStops, backgroundColor, borderWidth, borderColor,
      ## hGrid, vGrid, dontWrap and padding.
      ## todo ...
      
      ##########
      # Determine paragraph tag
      ##########
      put DecodeMetaDataArray(pStyledTextA[i]["metadata"]) into theMetaDataA
      put theMetaDataA["style"] into theParaStyle
      
      switch theParaStyle
         case "code"
            put "pre" into theParaTag
            break
            
         default
            if pStyledTextA[i]["style"]["listStyle"] is not empty then
               
               ##########
               # NOTE: This code does not support 'skip'.
               # <ul>
               # <li>Item
               #     <ol>
               #        <li>Sub item
               #     </ol>
               # </li>
               # </ul>
               ##########
               
               # Question 1) Are we are at same level and same depth?
               #    Yes: Do nothing
               #    No: Question 2
               
               # Question 2) Is the level increasing?
               #    Yes: Open new list (ul/ol).
               #    No: Do nothing. Already open.
               
               # 1)
               if pStyledTextA[i]["style"]["listStyle"] is not theParaListsA[the number of elements of theParaListsA]["listStyle"] \
                     OR pStyledTextA[i]["style"]["listDepth"] is not theParaListsA[the number of elements of theParaListsA]["listDepth"] then
                  switch pStyledTextA[i]["style"]["listStyle"]
                     case "disc"
                     case "circle"
                     case "square"
                        put "ul" into theListTag
                        break
                     default
                        put "ol" into theListTag
                        break
                  end switch
                  
                  # 2)
                  if pStyledTextA[i]["style"]["listDepth"] > theParaListsA[the number of elements of theParaListsA]["listDepth"] then
                     put "<" & theListTag & ">" after theXHTML
                  end if
                  
                  # add to nested list
                  put the number of elements of theParaListsA + 1 into theCounter
                  put theListTag into theParaListsA[theCounter]["tag"]
                  put pStyledTextA[i]["style"]["listStyle"] into theParaListsA[theCounter]["listStyle"]
                  put pStyledTextA[i]["style"]["listDepth"] into theParaListsA[theCounter]["listDepth"]
               end if
               
               put "li" into theParaTag
            else
               put "p" into theParaTag
            end if
      end switch
      
      put _DetermineXHTMLClassesForParagraph(pStyledTextA, i) into theParaClasses
      
      put "<" & theParaTag after theXHTML
      
      if pStyledTextA[i]["style"]["listIndex"] is not empty then
         put " value=" & quote & pStyledTextA[i]["style"]["listIndex"] & quote after theXHTML
      end if
      
      if theParaClasses is not empty then
         replace cr with space in theParaClasses
         put " class=" & quote & theParaClasses & quote after theXHTML
      end if
      
      put ">" after theXHTML
      
      put empty into theRun
      put empty into theString
      
      ##########
      # Add text runs to paragraph
      ##########
      repeat with j = 1 to the number of elements of pStyledTextA[i]["runs"]
         if pStyledTextA[i]["runs"][j] is not an array then next repeat
         
         put empty into theStyles
         
         ## style: textFont, textSize, textStyle, textColor, backgroundColor, linkText, imageSource
         --         pStyledTextA[i]["runs"][j]["style"]
         --         pStyledTextA[i]["runs"][j]["metadata"]
         --         pStyledTextA[i]["runs"][j]["text"]
         --         pStyledTextA[i]["runs"][j]["unicodetext"]
         
         # Normalize text run: UTF8
         if "unicodetext" is among the keys of pStyledTextA[i]["runs"][j] then
            put unidecode(pStyledTextA[i]["runs"][j]["unicodetext"], "utf8") into theRun
         else
            put unidecode(uniencode(pStyledTextA[i]["runs"][j]["text"]), "utf8") into theRun
         end if
         
         put _CleanseNonPrintingCharacters(theRun) into theRun
         put _EscapePredefinedXMLEntities(theRun) into theRun
         
         ##########
         ## Get meta data for rest of operations.
         ##########
         put DecodeMetaDataArray(pStyledTextA[i]["runs"][j]["metadata"]) into theMetaDataA
         
         # Modify for "code" style, etc.
         _UpdateTextBasedOnStyle theParaStyle, theMetaDataA["style"], theRun
         
         ##########
         ## Define Styles
         ##########
         if pStyledTextA[i]["runs"][j]["style"]["textColor"] is not empty then
            put "color: rgb(" & pStyledTextA[i]["runs"][j]["style"]["textColor"] & ")" into line (the number of lines of theStyles + 1) of theStyles
         end if
         
         if "underline" is among the items of pStyledTextA[i]["runs"][j]["style"]["textStyle"] then
            put "text-decoration:underline" into line (the number of lines of theStyles + 1) of theStyles
         end if
         
         ##########
         ## Add in tags and links
         ##########
         if pStyledTextA[i]["runs"][j]["style"]["linkText"] is not empty then
            ## this is how I stored target info for links
            ## Ensure that "&" in query string is converted to "&amp;"
            put TextToUTF8(pStyledTextA[i]["runs"][j]["style"]["linkText"]) into pStyledTextA[i]["runs"][j]["style"]["linkText"]
            put _EscapePredefinedXMLEntities(pStyledTextA[i]["runs"][j]["style"]["linkText"]) into pStyledTextA[i]["runs"][j]["style"]["linkText"]
            
            put "<a href=" & quote & pStyledTextA[i]["runs"][j]["style"]["linkText"] & quote into theLink
            repeat for each key theKey in theMetaDataA
               if theKey is "href target" then put "target" into theAttr
               else put theKey into theAttr
               
               put space & theAttr & "=" & quote & _EscapePredefinedXMLEntities(theMetaDataA[theKey]) & quote after theLink
            end repeat
            
            put ">" after theLink
            put theLink before theRun
            put "</a>" after theRun
         end if
         
         if pStyledTextA[i]["runs"][j]["style"]["textShift"] is an integer then
            if pStyledTextA[i]["runs"][j]["style"]["textShift"] < 0 then
               put "<sup>" before theRun
               put "</sup>" after theRun
            else if pStyledTextA[i]["runs"][j]["style"]["textShift"] > 0 then
               put "<sub>" before theRun
               put "</sub>" after theRun
            end if
         end if
         
         if "bold" is among the items of pStyledTextA[i]["runs"][j]["style"]["textStyle"] then
            put "<strong>" before theRun
            put "</strong>" after theRun
         end if
         
         if "italic" is among the items of pStyledTextA[i]["runs"][j]["style"]["textStyle"] then
            put "<em>" before theRun
            put "</em>" after theRun
         end if
         
         ##########
         ## Add in spans for styles
         ##########
         if theStyles is not empty then
            replace cr with ";" in theStyles
            
            ## Since each line will get a new <p> tag then we need to apply span to each line.
            put "<span style=" & quote & theStyles & quote & ">" before theRun
            put "</span>" after theRun
         end if
         
         put theRun after theString
      end repeat # Run
      
      ## Append new string
      put theString after theXHTML      
      
      # Close out the paragraph
      put "</" & theParaTag & ">" & cr after theXHTML
      
      ##########
      # Is listStyle changing/ending in next paragraph? Close out the list (ul/ol).
      ##########
      if theParaListsA is an array then
         
         # Question 1: are we at last paragraph?
         #     Yes: Close all open list paragraphs
         
         # Question 2: Is depth decreasing in next paragraph or is depth same but style different?
         #     Yes: Close paragraph and then check again. We may be closing out multiple lists.
         #     No: Don't close paragraph.
         
         if pStyledTextA[i+1] is not an array then
            # 1)
            repeat with theIndex = the number of elements of theParaListsA down to 1
               put "</" & theParaListsA[theIndex]["tag"] & ">" & cr after theXHTML
               delete local theParaListsA[theIndex]
            end repeat
         else
            # 2)
            repeat with theIndex = the number of elements of theParaListsA down to 1
               if pStyledTextA[i+1]["style"]["listDepth"] < theParaListsA[theIndex]["listDepth"] \
                     OR (pStyledTextA[i+1]["style"]["listDepth"] is theParaListsA[theIndex]["listDepth"] AND \
                     pStyledTextA[i+1]["style"]["listStyle"] is not theParaListsA[theIndex]["listStyle"]) then
                  put "</" & theParaListsA[theIndex]["tag"] & ">" & cr after theXHTML
                  delete local theParaListsA[theIndex]
               else
                  exit repeat
               end if
            end repeat
         end if
      end if
      
   end repeat # paragraph
   
   if the last char of theXHTML is cr then delete the last char of theXHTML
   
   ## Livecode has a run for empty paragraphs but XHTML adds spacing automatically.
   ## Get rid of those empty paragraphs.
   --   replace "</ul><p></p><ul>" with "</ul><ul>" in theXHTML
   --   replace "</ul><p></p><p>" with "</ul><p>" in theXHTML
   --   replace "</p><p></p><ul>" with "</p><ul>" in theXHTML
   --   replace "</p><p></p><p>" with "</p><p>" in theXHTML
   
   return theXHTML
end ConvertStyledTextToXHTML


/**
* |brief Inspects a paragraph and determines the XHTML classes to apply to it.
*
* \param @pStyledTextA the text run.
* \param pParaIndex The paragraph to inspect.
*
* \seealso ConvertStyledTextToXHTML
*
* \return String of classes, one per line.
*/
private function _DetermineXHTMLClassesForParagraph @pStyledTextA, pParaIndex
   if pStyledTextA[pParaIndex]["runs"] is not an array then return empty
   
   local theParaClasses
   local checkForIndent = "true"
   local theIndentLevel = 0
   
   repeat with i = 1 to the number of elements of pStyledTextA[pParaIndex]["runs"]      
      
      # Normalize text so we can inspect.
      if "unicodetext" is among the keys of pStyledTextA[pParaIndex]["runs"][i] then
         put unidecode(pStyledTextA[pParaIndex]["runs"][i]["unicodetext"], "utf8") into theRun
      else
         put unidecode(uniencode(pStyledTextA[pParaIndex]["runs"][i]["text"]), "utf8") into theRun
      end if
      
      # Look for tabs at start of line. We add a style for indenting: indent1, indent2, etc.      
      if checkForIndent then
         repeat for each char theChar in theRun
            if theChar is tab then
               add 1 to theIndentLevel
            else
               put false into checkForIndent
               exit repeat
            end if
         end repeat
      end if
   end repeat # Run
   
   # add tab indents to class
   if theIndentLevel > 0 then
      put "indent" & theIndentLevel into line (the number of lines of theParaClasses + 1) of theParaClasses
   end if
   
   return theParaClasses
end _DetermineXHTMLClassesForParagraph


/**
* |brief Makes any changes to a run based on the paragraph and run style.
*
* \param pParaStyle The style of the paragraph the run is in.
* \param pRunStyle The style of the run.
* \param @pText The text to modify.
*
* \return empty
*/
private command _UpdateTextBasedOnStyle pParaStyle, pRunStyle, @pText
   if pParaStyle is "code" OR pRunStyle is "code" then
      replace numToChar(11) with cr in pText
   else
      replace numToChar(11) with "<br />" in pText
   end if
   
   return empty
end _UpdateTextBasedOnStyle


local sStyledTextA, sStyledTextIndexPathA
local sXMLTreeStateA


/** 
* \brief Converts XHTML to a styled text array.
*
* \param pXHTML The XHTML to convert.
*
* \return XHTML
*/
function ConvertXHTMLtoStyledText pXHTML
   local theError, theStyledTextA
   
   if pXHTML is not empty then
      ## Strip returns existing after tags.
      ## This keeps unwanted revStartXMLData messages from firing.
      ## No effort made to strip other white space between tags. This type of 
      ## white space will fire off unwated revStartXMLData messages so beware.
      replace ">" & crlf with ">" in pXHTML
      replace ">" & cr with ">" in pXHTML
      replace ">" & lf with ">" in pXHTML
      
      ## Initialize some variables
      put empty into sXMLTreeStateA["run"]["textStyle"]
      put empty into sXMLTreeStateA["previous run"]["textStyle"]
      
      put qstr("<?xml version=`1.0` encoding=`UTF-8` ?>") into theHeader
      put revCreateXMLTree(theHeader & cr & "<body>" & pXHTML & "</body>", false, false, true) into theError
      put item 2 to -1 of theError into theError ## Ditches any numbers of revxmlerr, prefixes.
      
      put sStyledTextA into theStyledTextA
      put empty into sStyledTextA
   end if
   
   if theError is empty then
      return theStyledTextA
   else
      return theError
   end if
end ConvertXHTMLtoStyledText


on revXMLStartTree
   put empty into sStyledTextA
end revXMLStartTree


/**
* \brief 
*
* \param pNodeName The name of the node being parsed.
* \param pNodeAttributes One attribute per line. Each attribute name is separated from value by comma.
*
*/
on revStartXMLNode pNodeName, pNodeAttributes
   local theParaIndex
   
   put pNodeName into line (the number of lines of sXMLTreeStateA["open node"] + 1) of sXMLTreeStateA["open node"]
   
   split pNodeAttributes by cr and ","
   
   put the number of elements of sStyledTextA into theParaIndex
   
   switch pNodeName
      case "pre"         
      case "p" ## Start a new paragraph entry
         
         # TODO: <p> tags within <li> (LiveCode htmltext) are not handled properly.
         
         ## LiveCode likes an extra run to show paragraph spacing.
         ## Note: removed as we use spaceAbove now.
         --         if sXMLTreeStateA["block is open"] then
         --            add 1 to theParaIndex
         --            put empty into sStyledTextA[theParaIndex]["runs"]
         
         --            put false into sXMLTreeStateA["block is open"]
         --      end if
         
         # New paragraph: reset textStyle, textColor, etc.
         repeat for each key theKey in sXMLTreeStateA["run"]
            put empty into sXMLTreeStateA["run"][theKey]
         end repeat
         repeat for each key theKey in sXMLTreeStateA["previous run"]
            put empty into sXMLTreeStateA["previous run"][theKey]
         end repeat
         
         add 1 to theParaIndex
         
         put empty into sStyledTextA[theParaIndex]
         
         if theParaIndex > 1 then
            put 16 into sStyledTextA[theParaIndex]["style"]["spaceAbove"] ## trigger proper spacing
         end if
         
         switch pNodeName
            case "pre"
               put "code" into sStyledTextA[theParaIndex]["metadata"]["style"]
               break
         end switch
         
         put StringToIndexPath(theParaIndex & ".runs.1") into sStyledTextIndexPathA
         put empty into sStyledTextA[sStyledTextIndexPathA]["unicodetext"] # default value. If empty <p> tag all settings would be lost otherwise (i.e. spaceAbove).
         break
         
      case "ul"
         add 1 to sXMLTreeStateA["list depth"]
         put "disc" into sXMLTreeStateA["list type"][ sXMLTreeStateA["list depth"] ]
         break
         
      case "ol"
         add 1 to sXMLTreeStateA["list depth"]
         put "decimal" into sXMLTreeStateA["list type"][ sXMLTreeStateA["list depth"] ]
         break
         
      case "li"
         # New line: reset textStyle, textColor, etc.
         repeat for each key theKey in sXMLTreeStateA["run"]
            put empty into sXMLTreeStateA["run"][theKey]
         end repeat
         repeat for each key theKey in sXMLTreeStateA["previous run"]
            put empty into sXMLTreeStateA["previous run"][theKey]
         end repeat
         
         add 1 to theParaIndex
         
         ## trigger proper spacing for first line in list
         if sStyledTextA[theParaIndex - 1]["style"]["listStyle"] is empty then
            put 16 into sStyledTextA[theParaIndex]["style"]["spaceAbove"]
         end if
         
         put sXMLTreeStateA["list type"][ sXMLTreeStateA["list depth"] ] into sStyledTextA[theParaIndex]["style"]["listStyle"]
         if pNodeAttributes["value"] is not empty then put pNodeAttributes["value"] into sStyledTextA[theParaIndex]["style"]["listIndex"]
         put sXMLTreeStateA["list depth"] into sStyledTextA[theParaIndex]["style"]["listDepth"]
         put StringToIndexPath(theParaIndex & ".runs." & the number of elements of sStyledTextA[theParaIndex]["runs"] + 1) into sStyledTextIndexPathA
         break
         
      case "span"         
         ##########
         ## Strip whitespace
         ##########         
         --         text-decoration: underline; something-else: what
         put pNodeAttributes["style"] into theStyles
         set the itemDelimiter to ":"
         repeat with theItemNo = 1 to the number of items of theStyles["style"]
            put word 1 to -1 of item theItemNo of theStyles["style"] into item theItemNo of theStyles["style"]
         end repeat
         set the itemDelimiter to ";"
         repeat with theItemNo = 1 to the number of items of theStyles["style"]
            put word 1 to -1 of item theItemNo of theStyles["style"] into item theItemNo of theStyles["style"]
         end repeat
         set the itemDelimiter to ","
         repeat with theItemNo = 1 to the number of items of theStyles["style"]
            put word 1 to -1 of item theItemNo of theStyles["style"] into item theItemNo of theStyles["style"]
         end repeat
         
         set the wholematches to true
         
         split theStyles by ";" and ":"
         repeat for each key theKey in theStyles
            put word 1 to -1 of theStyles[theKey] into theStyles[theKey]
            
            switch theKey
               case "text-decoration"
                  if "underline" is among the items of theStyles[theKey] then
                     put _AddToList("underline", sXMLTreeStateA["run"]["textStyle"]) into sXMLTreeStateA["run"]["textStyle"]
                  end if
                  break
                  
               case "color"
                  if theStyles[theKey] begins with "rgb" then
                     put _StripNonNumericListChars(theStyles[theKey]) into sXMLTreeStateA["run"]["textColor"]
                  else
                     put theStyles[theKey] into sXMLTreeStateA["run"]["textColor"]
                  end if
                  break
            end switch
         end repeat
         break
         
      case "a"
         put _AddToList("link", sXMLTreeStateA["run"]["textStyle"]) into sXMLTreeStateA["run"]["textStyle"]
         put pNodeAttributes["href"] into sXMLTreeStateA["run"]["linkText"]
         replace "&#38;" with "&" in sXMLTreeStateA["run"]["linkText"] ## xml parser is converting &amp; to entity number.
         
         repeat for each key theKey in pNodeAttributes
            if theKey is "href" then next repeat
            
            if theKey is "target" then put "href target" into theAttr
            else put theKey into theAttr
            
            put pNodeAttributes[theKey] into sXMLTreeStateA["run"]["metadata"][theAttr]
         end repeat
         break
         
      case "sub"
         put 4 into sXMLTreeStateA["run"]["textShift"]
         break
         
      case "sup"
         put -4 into sXMLTreeStateA["run"]["textShift"]
         break
         
      case "b"
      case "strong"
         put _AddToList("bold", sXMLTreeStateA["run"]["textStyle"]) into sXMLTreeStateA["run"]["textStyle"]
         break
         
      case "i"
      case "em"
         put _AddToList("italic", sXMLTreeStateA["run"]["textStyle"]) into sXMLTreeStateA["run"]["textStyle"]
         break
         
      case "br"
         put uniencode(numToChar(11)) after sStyledTextA[sStyledTextIndexPathA]["unicodetext"]
         break
   end switch
end revStartXMLNode


/**
* \brief Sent when a node has finished being processed.
*
*/
on revEndXMLNode pNodeName
   ## Remove style from list of active styles.
   switch pNodeName
      case "a"
         put _RemoveFromList("link", sXMLTreeStateA["run"]["textStyle"]) into sXMLTreeStateA["run"]["textStyle"]
         put empty into sXMLTreeStateA["run"]["linkText"]
         delete local sXMLTreeStateA["run"]["metadata"]["href target"]
         break
      case "sub"
      case "sup"
         put empty into sXMLTreeStateA["run"]["textShift"]
         break
      case "b"
      case "strong"
         put _RemoveFromList("bold", sXMLTreeStateA["run"]["textStyle"]) into sXMLTreeStateA["run"]["textStyle"]
         break
      case "i"
      case "em"
         put _RemoveFromList("italic", sXMLTreeStateA["run"]["textStyle"]) into sXMLTreeStateA["run"]["textStyle"]
         break
      case "span"
         put _RemoveFromList("underline", sXMLTreeStateA["run"]["textStyle"]) into sXMLTreeStateA["run"]["textStyle"]
         put empty into sXMLTreeStateA["run"]["textColor"]
         break
         
      case "ul"
      case "ol"
         subtract 1 from sXMLTreeStateA["list depth"]
         break
         
      case "p"
      case "pre"
      case "li"
         # encode metadata
         put the number of elements of sStyledTextA into theParaIndex
         if sStyledTextA[theParaIndex]["metadata"] is an array then
            put EncodeMetaDataArray(sStyledTextA[theParaIndex]["metadata"]) into sStyledTextA[theParaIndex]["metadata"]
         end if
         break
   end switch
   
   delete line -1 of sXMLTreeStateA["open node"]
end revEndXMLNode


command revStartXMLData pData
   ## this message can be sent when no node is "open".
   switch line -1 of sXMLTreeStateA["open node"]
      case "ul"
      case "ol"
         break
      default
         ## Catch instances where string passed to ConvertXHTMLToStyledText doesn't start with <p> or <ol/ul>.
         if sStyledTextIndexPathA is not an array then
            put empty into sStyledTextA[1]
            put StringToIndexPath("1.runs.1") into sStyledTextIndexPathA
         end if
         
         ## If properties are changing on the text then start a new run.
         if sXMLTreeStateA["run"] is not sXMLTreeStateA["previous run"] then
            put the number of elements of sStyledTextA into theParaIndex
            put StringToIndexPath(theParaIndex & ".runs." & the number of elements of sStyledTextA[theParaIndex]["runs"] + 1) into sStyledTextIndexPathA
            _AddStylesAndColorToRun sStyledTextIndexPathA
         end if
         
         # Check among all lines as a pre may contain a span.
         if "pre" is among the lines of sXMLTreeStateA["open node"] then
            --         switch line -1 of sXMLTreeStateA["open node"]
            --      case "pre"
            ## convert lines to vertical tabs
            replace crlf with numToChar(11) in pData
            replace cr with numToChar(11) in pData
            replace lf with numToChar(11) in pData
            --         break
            --   end switch
         end if
         
         ## Use after so data isn't lost in situations where white space outside
         ## of tags causes unwanted message to fire.         
         put uniencode(pData, "utf8") after sStyledTextA[sStyledTextIndexPathA]["unicodetext"]
         --   put pData into sStyledTextA[sStyledTextIndexPathA]["text"] ## for testing
         
         ## Store run so we can compare next time through
         put sXMLTreeStateA["run"] into sXMLTreeStateA["previous run"]
   end switch
end revStartXMLData


on revXMLEndTree
   put empty into sXMLTreeStateA
   put empty into sStyledTextIndexPathA
end revXMLEndTree


/**
* \brief Escapes the predefined XML entities in a string.
*
* \param pStr The string to escape the characters in.
* \param pEscapeApostrophe Pass in true to escape apostrophes.
*
* \return String
*/
private function _EscapePredefinedXMLEntities pStr, pEscapeApostrophe
   replace "&" with "&amp;" in pStr
   replace "<" with "&lt;" in pStr
   replace ">" with "&gt;" in pStr
   replace quote with "&quot;" in pStr
   
   if pEscapeApostrophe then
      replace "'" with "&apos;" in pStr
   end if
   return pStr
end _EscapePredefinedXMLEntities


/**
* \brief Cleanses a string of non-printing characters that would mess up XML.
*
* \param pStr The string to work on.
*
* \return String
*/
private function _CleanseNonPrintingCharacters pStr
   repeat for each item theNum in "0,1,2,3,4,5,6,7,8"
      replace numToChar(theNum) with empty in pStr
   end repeat
   return pStr
end _CleanseNonPrintingCharacters


/**
* \brief Adds the currently active textStyle and textColor values to a run.
*
* \param pRunIndexPathA The index path array pointing to the run in the sStyledTextA array.
*
* \return empty
*/
command _AddStylesAndColorToRun pRunIndexPathA
   if sXMLTreeStateA["run"]["textShift"] is not empty then \
         put sXMLTreeStateA["run"]["textShift"] into sStyledTextA[pRunIndexPathA]["style"]["textShift"]
   
   if sXMLTreeStateA["run"]["textStyle"] is not empty then \
         put sXMLTreeStateA["run"]["textStyle"] into sStyledTextA[pRunIndexPathA]["style"]["textStyle"]
   
   if sXMLTreeStateA["run"]["textColor"] is not empty then \
         put sXMLTreeStateA["run"]["textColor"] into sStyledTextA[pRunIndexPathA]["style"]["textColor"]
   
   if sXMLTreeStateA["run"]["linkText"] is not empty then \
         put sXMLTreeStateA["run"]["linkText"] into sStyledTextA[pRunIndexPathA]["style"]["linkText"]
   
   if sXMLTreeStateA["run"]["metadata"] is an array then \
         put EncodeMetaDataArray(sXMLTreeStateA["run"]["metadata"]) into sStyledTextA[pRunIndexPathA]["metadata"]
   
   return empty
end _AddStylesAndColorToRun


/**
* \brief Strips non numeric chars from a string (except commas). Used for converting CSS rgb(x,x,x) to an RGB color that LiveCode likes.
*
* \param pString The string to strip characters from.
* 
* \return String
*/
private function _StripNonNumericListChars pString
   local i
   
   repeat with i = the number of chars of pString down to 1
      put char i of pString into theChar
      if theChar is not an integer AND theChar is not "," then
         delete char i of pString
      end if
   end repeat
   
   return pString
end _StripNonNumericListChars


/**
* \brief Adds an item to a list if it does not already exist.
*
* \param pItem The item to add.
* \param pList The list to add the item to.
*
* \return List
*/
private function _AddToList pItem, pList
   set the wholematches to true
   if pItem is not among the items of pList then
      put pItem into item (the number of items of pList + 1) of pList
   end if
   return pList
end _AddToList


/**
* \brief Removes an item from a list.
*
* \param pItem The item to remove.
* \param pList The list to remove the item from.
*
* \return List
*/
private function _RemoveFromList pItem, pList
   set the wholematches to true
   put itemOffset(pItem, pList) into theItemNo
   if theItemNo > 0 then delete item theItemNo of pList
   return pList
end _RemoveFromList


/**
* |brief Encodes an array so it can be stored as the metadata property of a field chunk.
*
*/
function EncodeMetaDataArray pArrayA
   if pArrayA is an array then
      return base64Encode(arrayEncode(pArrayA))
   else
      return pArrayA
   end if
end EncodeMetaDataArray


function DecodeMetaDataArray pData
   try
      return arrayDecode(base64Decode(pData))
   catch e
      return pData
   end try
end DecodeMetaDataArray