HTMLWriterIntf.pas

 unit HTMLWriterIntf;

{$REGION 'License'}
{
  Copyright (C) 2010 Nick Hodges

  This Source Code Form is subject to the terms of the Mozilla Public
  License, v. 2.0. If a copy of the MPL was not distributed with this
  file, You can obtain one at https://mozilla.org/MPL/2.0/.
}
{$ENDREGION}

interface

uses
      HTMLWriterUtils
    , Classes
    , SysUtils
    , LoadSaveIntf
    ;

type
  /// <summary>An interface for creating HTML.  IHTMLWriter uses the fluent interface. It can be used to create either
  /// complete HTML documents or chunks of HTML.  By using the fluent interface, you can link together number of methods
  /// to create a complete document.</summary>
  /// <remarks>
  /// <para>Most methods begin with either "Open" or "Add". Methods that start with "Open" will
  /// add  &lt;tag&gt;  to the HTML stream, leaving it ready for the addition of attributes or other content. The
  /// system will automatically close the tag when necessary.</para>
  /// <para>Methods that start with "Add" will normally take paramenters and then add content within a complete tag
  /// pair. For example, a call to AddBoldText('blah') will result in  &lt;b&gt;blah&lt;/b&gt;  being added to
  /// the HTML stream.</para>
  /// <para>Some things to note:</para>
  /// <list type="bullet">
  /// <item>Any tag that is opened will need to be closed via  CloseTag</item>
  /// <item>Any tag that is added via a  AddXXXX  call will close itself.</item>
  /// <item>The rule to follow: Close what you open. Additions take care of themselves.</item>
  /// <item>Certain tags like  &lt;meta&gt;  and  &lt;base&gt;  can only be added inside
  /// at  &lt;head&gt;  tag.</item>
  /// <item>Tags such as  &lt;td&gt;,  &lt;tr&gt;  can only be added inside of
  /// a  &lt;table&gt;  tag.</item>
  /// <item>The same is true for list items inside lists.</item>
  /// </list>
  /// </remarks>
  IHTMLWriter = interface(ILoadSave)
  ['{7D6CC975-3FAB-453C-8BAB-45D6E55DE376}']
    function GetAttribute(const Name, Value: string): IHTMLWriter;
    function GetErrorLevels: THTMLErrorLevels;
    procedure SetErrorLevels(const Value: THTMLErrorLevels);
    function GetHTML: TStringBuilder;
    function AddTag(aString: string; aCloseTagType: TCloseTagType = ctNormal; aCanAddAttributes: TCanHaveAttributes = chaCanHaveAttributes): IHTMLWriter;
    /// <summary>Opens a&lt;head&gt; tag to the document.  </summary>
    function OpenHead: IHTMLWriter;
    /// <summary>Opens a &lt;meta&gt; tag.</summary>
    /// <exception cref="EHeadTagRequiredHTMLException">Raised if an attempt is made  to call this method
    /// when not inside a &lt;head&gt; tag.</exception>
    /// <remarks>Note that this method can only be called from within &lt;head&gt; tag.   If it is called from
    /// anywhere else, it will raise an exception.</remarks>
    function OpenMeta: IHTMLWriter;
    /// <summary>Opens a &lt;base /&gt; tag.</summary>
    /// <exception cref="EHeadTagRequiredHTMLException">Raised if this tag is added outside of the &lt;head&gt;
    /// tag.</exception>
    /// <remarks>This tag will always be closed with the '/&gt;' tag. In addition, this tag can only be added inside of
    /// a &lt;head&gt; tag.</remarks>
    function OpenBase: IHTMLWriter;
    /// <summary>Opens a &lt;basefont&gt; tag.</summary>
    /// <remarks>This tag is deprecated in HTML 4.01 and HTML5.</remarks>
    function OpenBaseFont: IHTMLWriter;
    ///	<summary>Adds a &lt;base /&gt; tag to the HTML.</summary>
    ///	<remarks>Note: This method can only be called inside an open &lt;head&gt; tag.</remarks>
    function AddBase(aTarget: TTargetType; aFrameName: string = ''): IHTMLWriter; overload;
    ///	<summary>Creates a &lt;base&gt; tag with an HREF="" attribute.</summary>
    ///	<param name="aHREF">The HREF to be added to the &lt;base&gt; tag as an attribute.</param>
    function AddBase(aHREF: string): IHTMLWriter; overload;
    /// <summary>Opens a &lt;title&gt; tag.</summary>
    function OpenTitle: IHTMLWriter;
    /// <summary>Adds a &lt;title&gt; tag including the passed in text.</summary>
    /// <param name="aTitleText">The text to be placed inside the &lt;title&gt;&lt;/title&gt; tag</param>
    /// <remarks>There is no need to close this tag manually.   All "AddXXXX" methods close themselves.</remarks>
    function AddTitle(aTitleText: string): IHTMLWriter;
    /// <summary>Adds a &lt;meta&gt; tag with name and content attributes.</summary>
    /// <param name="aName">The value for the name attribute.</param>
    /// <param name="aContent">The value for the content attribute.</param>
    function AddMetaNamedContent(aName: string; aContent: string): IHTMLWriter;
    /// <summary>Opens a &lt;body&gt; tag.</summary>
    function OpenBody: IHTMLWriter;
   /// <summary>Opens a &lt;p&gt; tag.  </summary>
    function OpenParagraph: IHTMLWriter;
    /// <summary>Opens a &lt;p&gt; tag and gives it the passed in style="" attribute</summary>
    /// <param name="aStyle">The CSS-based text to be included in the style attribute for the &lt;p&gt; tag.</param>
    function OpenParagraphWithStyle(aStyle: string): IHTMLWriter;
    /// <summary>Opens a &lt;p&gt; tag with an id="" attribute.</summary>
    /// <param name="aID">The value for the id attribute.</param>
    function OpenParagraphWithID(aID: string): IHTMLWriter;
    /// <summary>Opens a &lt;span&gt; tag.</summary>
    function OpenSpan: IHTMLWriter;
    /// <summary>Opens a &lt;div&gt; tag.</summary>
    function OpenDiv: IHTMLWriter;
    /// <summary>Opens a &lt;blockquote&gt; tag.</summary>
    function OpenBlockQuote: IHTMLWriter;
    /// <summary>Adds the passed in text to the HTML inside of a &lt;p&gt; tag.</summary>
    /// <param name="aString">The text to be added into the &lt;p&gt; tag.</param>
    function AddParagraphText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text into a &lt;p&gt; tag and adds in the given Style attribute.</summary>
    /// <param name="aString">The text to be added within the &lt;p&gt; tag.</param>
    /// <param name="aStyle">The value for the Style attribute  to be added to the &lt;p&gt; tag.</param>
    function AddParagraphTextWithStyle(aString: string; aStyle: string): IHTMLWriter;
    /// <summary>Adds the passed in text into a &lt;p&gt; tag with an id="" attribute.</summary>
    /// <param name="aString">The text to be added within the &lt;p&gt; tag.</param>
    /// <param name="aID">The value for the id attribute.</param>
    function AddParagraphTextWithID(aString: string; aID: string): IHTMLWriter;
    /// <summary>Adds the passed in text into a &lt;p&gt; tag with a class="" attribute.</summary>
    /// <param name="aString">The text to be added within the &lt;p&gt; tag.</param>
    /// <param name="aClass">The value for the class attribute.</param>
    function AddParagraphTextWithClass(aString: string; aClass: string): IHTMLWriter;
    /// <summary>Adds text inside of a &lt;span&gt; tag.</summary>
    /// <param name="aString">The text to be added inside of the &lt;span&gt;&lt;/span&gt; tag.</param>
    function AddSpanText(aString: string): IHTMLWriter;
    /// <summary>Adds text inside a &lt;span&gt; tag with a style="" attribute.</summary>
    /// <param name="aString">The text to be added inside the &lt;span&gt; tag.</param>
    /// <param name="aStyle">The CSS style value for the style attribute.</param>
    function AddSpanTextWithStyle(aString: string; aStyle: string): IHTMLWriter;
    /// <summary>Adds text inside a &lt;span&gt; tag with an id="" attribute.</summary>
    /// <param name="aString">The text to be added inside the &lt;span&gt; tag.</param>
    /// <param name="aID">The value for the id attribute.</param>
    function AddSpanTextWithID(aString: string; aID: string): IHTMLWriter;
    /// <summary>Adds text inside a &lt;span&gt; tag with a class="" attribute.</summary>
    /// <param name="aString">The text to be added inside the &lt;span&gt; tag.</param>
    /// <param name="aID">The value for the class attribute.</param>
    function AddSpanTextWithClass(aString: string; aID: string): IHTMLWriter;
    ///	<summary>Adds the passed in text to a &lt;div&gt;&lt;/div&gt; tag.</summary>
    ///	<param name="aString">The text to be added inside the &lt;div&gt;&lt;/div&gt; tag</param>
    function AddDivText(aString: string): IHTMLWriter;
    ///	<summary>Creates a &lt;div&gt; tag with a "style=" attribute.</summary>
    ///	<param name="aString">The text to be placed in the &lt;div&gt; tag.</param>
    ///	<param name="aStyle">A string representing the CSS style information for the &lt;div&gt; tag.</param>
    function AddDivTextWithStyle(aString: string; aStyle: string): IHTMLWriter;
    ///	<summary>Creates a &lt;div&gt; tag with a "id=" attribute.</summary>
    ///	<param name="aString">The text to be placed in the &lt;div&gt; tag.</param>
    ///	<param name="aID">As string containing the id value for the &lt;div&gt; tag.</param>
    function AddDivTextWithID(aString: string; aID: string): IHTMLWriter;
    ///	<summary>Creates a &lt;div&gt; tag with a "class=" attribute.</summary>
    ///	<param name="aString">The text to be placed in the &lt;div&gt; tag.</param>
    ///	<param name="aID">As string containing the class value for the &lt;div&gt; tag.</param>
    function AddDivTextWithClass(aString: string; aClass: string): IHTMLWriter;
    /// <summary>Opens up a &lt;b&gt; tag. Once a tag is open, it can be added to as desired.</summary>
    function OpenBold: IHTMLWriter;
    /// <summary>Opens up a &lt;i&gt; tag. Once a tag is open, it can be added to as desired.</summary>
    function OpenItalic: IHTMLWriter;
    /// <summary>Opens up a &lt;u&gt; tag. Once a tag is open, it can be added to as desired.</summary>
    function OpenUnderline: IHTMLWriter;
    /// <summary>Opens a &lt;em&gt; tag.</summary>
    function OpenEmphasis: IHTMLWriter;
    /// <summary>Opens a &lt;strong&gt; tag.</summary>
    function OpenStrong: IHTMLWriter;
    /// <summary>Opens a &lt;pre&gt; tag.</summary>
    function OpenPre: IHTMLWriter;
    /// <summary>Opens a &lt;cite&gt; tag.</summary>
    function OpenCite: IHTMLWriter;
    /// <summary>Opens a &lt;acronym&gt; tag.</summary>
    function OpenAcronym: IHTMLWriter;
    /// <summary>Opens an &lt;abbr&gt; tag.</summary>
    function OpenAbbreviation: IHTMLWriter;
    /// <summary>Opens an &lt;addr&gt; tag</summary>
    function OpenAddress: IHTMLWriter;
    /// <summary>Opens a &lt;bdo&gt; tag.</summary>
    function OpenBDO: IHTMLWriter;
    /// <summary>Opens a &lt;big&gt; tag.</summary>
    function OpenBig: IHTMLWriter;
    /// <summary>Opens a &lt;center&gt; tag.</summary>
    function OpenCenter: IHTMLWriter;
    /// <summary>Opens a &lt;code&gt; tag.</summary>
    function OpenCode: IHTMLWriter;
    /// <summary>Opens a &lt;del&gt; tag.</summary>
    function OpenDelete: IHTMLWriter;
    /// <summary>Opens a &lt;dfn&gt; tag.</summary>
    function OpenDefinition: IHTMLWriter;
    /// <summary>Opens a &lt;font&gt; tag.</summary>
    function OpenFont: IHTMLWriter;
    /// <summary>Opens a &lt;kbd&gt; tag</summary>
    function OpenKeyboard: IHTMLWriter;
    /// <summary>Opens a &lt;q&gt; tag.  </summary>
    function OpenQuotation: IHTMLWriter;
    /// <summary>Opens a &lt;sample&gt; tag.</summary>
    function OpenSample: IHTMLWriter;
    /// <summary>Opens a &lt;small&gt; tag.</summary>
    function OpenSmall: IHTMLWriter;
    /// <summary>Opens a &lt;strike&gt; tag.</summary>
    function OpenStrike: IHTMLWriter;
    /// <summary>Opens a &lt;tt&gt; tag.</summary>
    function OpenTeletype: IHTMLWriter;
    /// <summary>Opens a &lt;var&gt; tag.</summary>
    function OpenVariable: IHTMLWriter;
    /// <summary>Opens a &lt;ins&gt; tag.</summary>
    function OpenInsert: IHTMLWriter;
    /// <summary>Adds a &lt;b&gt;&lt;/b&gt; containing the passed text</summary>
    /// <param name="aString">The text to be placed within the bold tag.</param>
    function AddBoldText(aString: string): IHTMLWriter;
    /// <summary>Adds a &lt;i&gt;&lt;/i&gt; containing the passed text</summary>
    /// <param name="aString">The text to be placed within the italic tag.</param>
    function AddItalicText(aString: string): IHTMLWriter;
    /// <summary>
    ///   Adds a &lt;u&gt;&lt;/u&gt; containing the passed text
    /// </summary>
    /// <param name="aString">
    ///   The text to be placed within the underline tag. <br />
    /// </param>
    function AddUnderlinedText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed text inside of a &lt;em&gt;&lt;/em&gt; tag</summary>
    /// <param name="aString">The text to be added inside the Emphasis tag.</param>
    function AddEmphasisText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;strong&gt;&lt;/strong&gt; tag.</summary>
    /// <param name="aString">The text to be added to the strong tag.</param>
    function AddStrongText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;pre&gt;&lt;/pre&gt; tag</summary>
    /// <param name="aString">The text to be added inside a preformatted tag</param>
    function AddPreformattedText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;cite&lt;&lt;/cite&gt; tag</summary>
    /// <param name="aString">The text to be added inside the Citation tag.</param>
    function AddCitationText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text inside of a &lt;blockquote&gt;&lt;/blockquote&gt; tag.</summary>
    /// <param name="aString">The text to be included inside the block quote tag.</param>
    function AddBlockQuoteText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to an &lt;acronym&gt;&lt;/acronym&gt; tag.</summary>
    /// <param name="aString">The string that will be included in the Acronym tag.</param>
    function AddAcronymText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;abbr&gt;&lt;/abbr&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the Abbreviation tag.</param>
    function AddAbbreviationText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;addr&gt;&lt;/addr&gt; tag.</summary>
    /// <param name="aString">The text to be included in the Address tag.</param>
    function AddAddressText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;bdo&gt;&lt;/bdo&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the Bi-Directional tag.</param>
    function AddBDOText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;big&gt;&lt;/big&gt; tag.</summary>
    /// <param name="aString">The text to eb added to the Big tag.</param>
    function AddBigText(aString: string): IHTMLWriter;
    /// <summary>Addes the passed in text to a &lt;center&gt;&lt;/center&gt; tag.</summary>
    /// <param name="aString">The text to be added to the Center tag.</param>
    function AddCenterText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;code&gt;&lt;/code&gt; tag.</summary>
    /// <param name="aString">The text to be added to the Code tag.</param>
    function AddCodeText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;del&gt;&lt;/del&gt; tag.</summary>
    /// <param name="aString">The text to be added to the Delete tag.</param>
    function AddDeleteText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;dfn&gt;&lt;/dfn&gt; tag.</summary>
    /// <param name="aString">The text to be added inside of the Definition tag.</param>
    function AddDefinitionText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;font&gt;&lt;/font&gt; tag.</summary>
    /// <param name="aString">The text to be included in the Font tag.</param>
    function AddFontText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;kbd&gt;&lt;/kbd&gt; tag.</summary>
    /// <param name="aString">The text to be added to the Keyboard tag.</param>
    function AddKeyboardText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;q&gt;&lt;/q&gt; tag</summary>
    /// <param name="aString">The string that will be included inside the quotation tag.</param>
    function AddQuotationText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;samp&gt;&lt;/samp&gt; tag.</summary>
    /// <param name="aString">The text to be inserted into the sample tag.</param>
    function AddSampleText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;small&gt;&lt;/small&gt; tag</summary>
    /// <param name="aString">The text to be included in a small tag.</param>
    function AddSmallText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;strike&gt;&lt;/strike&gt; tag</summary>
    /// <param name="aString">The text to be included in the strike tag.</param>
    function AddStrikeText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;tt&gt;&lt;/tt&gt; tag.</summary>
    /// <param name="aString">The text to be added into the teletype tag.</param>
    function AddTeletypeText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;var&gt;&lt;/var&gt; tag</summary>
    /// <param name="aString">The text to be passed to the variable tag.</param>
    function AddVariableText(aString: string): IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;ins&gt;&lt;/ins&gt; tag</summary>
    /// <param name="aString">The text to be passed to the insert tag.</param>
    function AddInsertText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;h1&gt; tag.</summary>
    function OpenHeading1: IHTMLWriter;
    /// <summary>Opens a &lt;h2&gt; tag.</summary>
    function OpenHeading2: IHTMLWriter;
    /// <summary>Opens a &lt;h3&gt; tag.</summary>
    function OpenHeading3: IHTMLWriter;
    /// <summary>Opens a &lt;h4&gt; tag.</summary>
    function OpenHeading4: IHTMLWriter;
    /// <summary>Opens a &lt;h5&gt; tag.</summary>
    function OpenHeading5: IHTMLWriter;
    /// <summary>Opens a &lt;h6&gt; tag.</summary>
    function OpenHeading6: IHTMLWriter;
    /// <summary>Inserts a &lt;h1&gt;&lt;/h1&gt; tag and places the given text in it.</summary>
    /// <param name="aString">The text to be placed inside the heading tag.</param>
    function AddHeading1Text(aString: string): IHTMLWriter;
    /// <summary>Inserts a &lt;h2&gt;&lt;/h2&gt; tag and places the given text in it.</summary>
    /// <param name="aString">The text to be placed inside the heading tag.</param>
    function AddHeading2Text(aString: string): IHTMLWriter;
    /// <summary>Inserts a &lt;h3&gt;&lt;/h3&gt; tag and places the given text in it.</summary>
    /// <param name="aString">The text to be placed inside the heading tag.</param>
    function AddHeading3Text(aString: string): IHTMLWriter;
    /// <summary>Inserts a &lt;h4&gt;&lt;/h4&gt; tag and places the given text in it.</summary>
    /// <param name="aString">The text to be placed inside the heading tag.</param>
    function AddHeading4Text(aString: string): IHTMLWriter;
    /// <summary>Inserts a &lt;h5&gt;&lt;/h5&gt; tag and places the given text in it.</summary>
    /// <param name="aString">The text to be placed inside the heading tag.</param>
    function AddHeading5Text(aString: string): IHTMLWriter;
    /// <summary>Inserts a &lt;h6&gt;&lt;/h6&gt; tag and places the given text in it.</summary>
    /// <param name="aString">The text to be placed inside the heading tag.</param>
    function AddHeading6Text(aString: string): IHTMLWriter;
    ///	<summary>Addes a style="" attribute to the current HTML.</summary>
    ///	<param name="aStyle">The string that contains the styling information in CSS format.</param>
    ///	<exception cref="EHTMLWriterOpenTagRequiredException">Raised if this method is called while a tag is not open.</exception>
    ///	<remarks>This method can only be called when a tag is open and ready to take attributes.</remarks>
    function AddStyle(aStyle: string): IHTMLWriter;
    ///	<summary>Adds a class="" attribute to the current tag.</summary>
    ///	<param name="aClass">The name of the class to be added in the attribute.</param>
    ///	<exception cref="EHTMLWriterOpenTagRequiredException">Raised if this method is called while a tag is not open.</exception>
    ///	<remarks>This method can only be called when a tag is open and ready to take attributes.</remarks>
    function AddClass(aClass: string): IHTMLWriter;
    ///	<summary>Adds an id="" attribute to the current tag.</summary>
    ///	<param name="aID">The string containing the ID to be included with the attribute.</param>
    ///	<exception cref="EHTMLWriterOpenTagRequiredException">Raised if this method is called while a tag is not open.</exception>
    ///	<remarks>This method can only be called when a tag is open and ready to take attributes.</remarks>
    function AddID(aID: string): IHTMLWriter;
    /// <summary>Adds an attribute to the current tag.   The tag must have its bracket open.  </summary>
    /// <param name="aString">The name of the attribute to be added.   If this is the only parameter passed in,
    /// then this string should contain the entire attribute string.</param>
    /// <param name="aValue">Optional parameter.   If this value is passed, then the first parameter become the
    /// <i>name</i>, and this one the <i>value</i>, in a <i>name=value</i> pair.</param>
    /// <exception cref="EHTMLWriterOpenTagRequiredException">Raised when this method is called on a tag that doesn't
    /// have it's bracket open.</exception>
    function AddAttribute(aString: string; aValue: string = ''): IHTMLWriter;
    /// <summary>Adds a &lt;br /&gt; tag</summary>
    /// <param name="aClearValue">An optional parameter that determines if a clear attribute will be added.   The
    /// default value is not to include the clear attribute.</param>
    /// <param name="aUseCloseSlash">An optional parameter that determines if the tag will close with a /&gt;.
    /// The default is to do so.</param>
    function AddLineBreak(const aClearValue: TClearValue = cvNoValue; aUseEmptyTag: TIsEmptyTag = ietIsEmptyTag): IHTMLWriter;
    /// <summary>Adds an &lt;hr&gt; tag to the HTML</summary>
    /// <param name="aAttributes">Attributes that should be added to the &lt;hr&gt; tag.</param>
    /// <param name="aUseEmptyTag">Determines if the &lt;hr&gt; tag should be rendered as &lt;hr /&gt;</param>
    function AddHardRule(const aAttributes: string = ''; aUseEmptyTag: TIsEmptyTag = ietIsEmptyTag): IHTMLWriter;
    /// <summary>Adds a Carriage Return and a Line Feed to the HTML.</summary>
    function CRLF: IHTMLWriter;
    /// <summary>Adds spaces to the HTML stream</summary>
    /// <param name="aNumberofSpaces">An integer indicating how many spaces should be added to the HTML.</param>
    function Indent(aNumberofSpaces: integer): IHTMLWriter;
    /// <summary>Opens a &lt;comment&gt; tag</summary>
    function OpenComment: IHTMLWriter;
    /// <summary>Adds any text to the HTML.  </summary>
    /// <param name="aString">The string to be added</param>
    /// <remarks>AddText will close the current tag and then add the text passed in the string parameter</remarks>
    function AddText(aString: string): IHTMLWriter;
    /// <summary>AddRawText will inject the passed in string directly into the HTML.  </summary>
    /// <param name="aString">The text to be added to the HTML</param>
    /// <remarks>AddRawText  will not make any other changes to open tags or open brackets.   It just injects
    /// the passed text directly onto the HTML.</remarks>
    function AddRawText(aString: string): IHTMLWriter;
    /// <summary>Returns a string containing the current HTML for the
    /// HTMLWriter</summary>
    /// <remarks>This property will return the HTML in whatever state it is
    /// in when called.   This may mean that brackets or even tags are
    /// open, attributes hanging undone, etc.  </remarks>
    function AsHTML: string;
    /// <summary>Adds a comment to the HTML stream</summary>
    /// <param name="aCommentText">The text to be added inside the comment</param>
    function AddComment(aCommentText: string): IHTMLWriter;
    /// <summary>Opens a &lt;script&gt; tag</summary>
    function OpenScript: IHTMLWriter;
    /// <summary>Adds the passed in script text to a &lt;script&gt;&lt;/script&gt; tag.</summary>
    /// <param name="aScriptText">The script text to be added inside the Script tag.</param>
    function AddScript(aScriptText: string): IHTMLWriter;
    ///	<summary>Opens a &lt;noscript&gt; tag</summary>
    function OpenNoScript: IHTMLWriter;
    /// <summary>Opens a &lt;link /&gt; tag.</summary>
    function OpenLink: IHTMLWriter;
    /// <summary>Closes an open tag.</summary>
    /// <param name="aUseCRLF">Determines if CRLF should be added after the closing of the tag.</param>
    /// <exception cref="ETryingToCloseClosedTag">Raised if you try to close a tag when no tag is open.</exception>
    function CloseTag(aUseCRLF: TUseCRLFOptions = ucoNoCRLF): IHTMLWriter;
    /// <summary>Closes an open comment tag.</summary>
    function CloseComment: IHTMLWriter;
    /// <summary>Closes an open &lt;list&gt; tag</summary>
    function CloseList: IHTMLWriter;
    /// <summary>Closes an open &lt;table&gt; tag.</summary>
    function CloseTable: IHTMLWriter;
    /// <summary>Closes and open &lt;form&gt; tag.</summary>
    function CloseForm: IHTMLWriter;
    /// <summary>Closes and open &lt;html&gt; tag.</summary>
    function CloseDocument: IHTMLWriter;
    /// <summary>Opens in &lt;img&gt; tag.</summary>
    /// <remarks>This tag will always be closed by " /&gt;"</remarks>
    function OpenImage: IHTMLWriter; overload;
    /// <summary>Opens an &lt;img&gt; tag and adds the 'src' parameter.</summary>
    /// <param name="aImageSource">The URL of the image to be displayed</param>
    function OpenImage(aImageSource: string): IHTMLWriter; overload;
    /// <summary>Adds a complete &lt;img /&gt; tag with the given source.</summary>
    /// <param name="aImageSource">The URL of the image to be displayed.</param>
    function AddImage(aImageSource: string): IHTMLWriter;
    /// <summary>Opens an &lt;a&gt; tag.</summary>
    function OpenAnchor: IHTMLWriter; overload;
    /// <summary>Opens an &lt;a&gt; tag with a name attribute.</summary>
    /// <param name="aName">The value for the name attribute.</param>
    function OpenAnchor(aName: string): IHTMLWriter; overload;
    /// <summary>Opens an &lt;a&gt; tag with an href attribute and adds text content.</summary>
    /// <param name="aHREF">The URL for the href attribute.</param>
    /// <param name="aText">The text to be displayed inside the anchor tag.</param>
    function OpenAnchor(const aHREF: string; aText: string): IHTMLWriter; overload;
    /// <summary>Adds a complete &lt;a&gt;&lt;/a&gt; tag with href and text content.</summary>
    /// <param name="aHREF">The URL for the href attribute.</param>
    /// <param name="aText">The text to be displayed inside the anchor tag.</param>
    function AddAnchor(const aHREF: string; aText: string): IHTMLWriter; overload;
    /// <summary>Opens a &lt;table&gt; tag</summary>
    /// <remarks>You cannot use other table related tags (&lt;tr&gt;, &lt;td&gt;, etc.) until a &lt;table&gt; tag is
    /// open.</remarks>
    function OpenTable: IHTMLWriter; overload;
    /// <summary>Opens a &lt;table&gt; tag and adds the 'border' attribute</summary>
    function OpenTable(aBorder: integer): IHTMLWriter; overload;

    {$REGION 'Documentation'}
    ///	<summary>
    ///	  Opens a &lt;table&gt; tag with border and cellpadding attributes
    ///	</summary>
    ///	<param name="aBorder">
    ///	  The value to be added as the border attribute
    ///	</param>
    ///	<param name="aCellPadding">
    ///	  The value to be added as the cellpadding attribute
    ///	</param>
    {$ENDREGION}
    function OpenTable(aBorder: integer; aCellPadding: integer): IHTMLWriter; overload;
    /// <summary>Opens a &lt;table&gt; tag with border, cellpadding, and cellspacing attributes.</summary>
    /// <param name="aBorder">The value for the border attribute.</param>
    /// <param name="aCellPadding">The value for the cellpadding attribute.</param>
    /// <param name="aCellSpacing">The value for the cellspacing attribute.</param>
    function OpenTable(aBorder: integer; aCellPadding: integer; aCellSpacing: integer): IHTMLWriter; overload;
    /// <summary>Opens a &lt;table&gt; tag with border, cellpadding, cellspacing, and width attributes.</summary>
    /// <param name="aBorder">The value for the border attribute.</param>
    /// <param name="aCellPadding">The value for the cellpadding attribute.</param>
    /// <param name="aCellSpacing">The value for the cellspacing attribute.</param>
    /// <param name="aWidth">The width specification for the table.</param>
    function OpenTable(aBorder: integer; aCellPadding: integer; aCellSpacing: integer; aWidth: THTMLWidth): IHTMLWriter; overload;
    /// <summary>Opens a &lt;tr&gt; tag.</summary>
    function OpenTableRow: IHTMLWriter;
    /// <summary>Opens a &lt;td&gt; tag.</summary>
    /// <remarks>This method can only be called when a &lt;tr&gt; tag is open.</remarks>
    function OpenTableData: IHTMLWriter;

    {$REGION 'Documentation'}
    ///	<summary>
    ///	  Opens a &lt;th&gt; tag
    ///	</summary>
    {$ENDREGION}
    function OpenTableHeader: IHTMLWriter;
    /// <summary>Opens a &lt;thead&gt; tag.</summary>
    /// <remarks>This method can only be called inside a &lt;table&gt; tag.</remarks>
    function OpenTableHead: IHTMLWriter;
    /// <summary>Opens a &lt;tbody&gt; tag.</summary>
    /// <remarks>This method can only be called inside a &lt;table&gt; tag.</remarks>
    function OpenTableBody: IHTMLWriter;
    /// <summary>Opens a &lt;tfoot&gt; tag.</summary>
    /// <remarks>This method can only be called inside a &lt;table&gt; tag.</remarks>
    function OpenTableFoot: IHTMLWriter;
    /// <summary>Adds the given text inside of a &lt;td&gt; tag.</summary>
    /// <exception cref="ENotInTableTagException">Raised when an attempt is made to add something in a table when the appropriate tag is not open.</exception>
    /// <remarks>This tag can only be added while a table row &lt;tr&gt; tag is open. Otherwise, an exception is raised.</remarks>
    function AddTableData(aText: string): IHTMLWriter;

    {$REGION 'Documentation'}
    ///	<summary>
    ///	  Opens a &lt;caption&gt; tag
    ///	</summary>
    {$ENDREGION}
    function OpenCaption: IHTMLWriter;
    /// <summary>Opens a &lt;colgroup&gt; tag.</summary>
    /// <remarks>This method can only be called inside a &lt;table&gt; tag before any table content.</remarks>
    function OpenColGroup: IHTMLWriter;
    /// <summary>Opens a &lt;col /&gt; tag.</summary>
    /// <remarks>This method can only be called inside a &lt;table&gt; tag before any table content.</remarks>
    function OpenCol: IHTMLWriter;
    /// <summary>Opens a &lt;form&gt; tag.</summary>
    /// <param name="aActionURL">The URL for the action attribute. If empty, no action attribute is added.</param>
    /// <param name="aMethod">The HTTP method for the form (GET or POST).</param>
    function OpenForm(aActionURL: string = ''; aMethod: TFormMethod = fmGet): IHTMLWriter;
    /// <summary>Opens an &lt;input /&gt; tag.</summary>
    /// <remarks>This method can only be called inside a &lt;form&gt; tag.</remarks>
    function OpenInput: IHTMLWriter; overload;
    /// <summary>Opens an &lt;input /&gt; tag with type and optional name attributes.</summary>
    /// <param name="aType">The input type (text, password, checkbox, etc.).</param>
    /// <param name="aName">The optional name attribute value.</param>
    /// <remarks>This method can only be called inside a &lt;form&gt; tag.</remarks>
    function OpenInput(aType: TInputType; aName: string = ''): IHTMLWriter; overload;

    {$REGION 'Documentation'}
    ///	<summary>
    ///	  Opens a &lt;button&gt; tag
    ///	</summary>
    ///	<param name="aName">
    ///	  Required attribute.� Value given for the 'name' attribute.� All
    ///	  buttons must be named.
    ///	</param>
    {$ENDREGION}
    function OpenButton(aName: string): IHTMLWriter;

    {$REGION 'Documentation'}
    ///	<summary>
    ///	  Opens a &lt;label&gt; tag
    ///	</summary>
    {$ENDREGION}
    function OpenLabel: IHTMLWriter; overload;
    /// <summary>Opens a &lt;label&gt; tag with a for="" attribute.</summary>
    /// <param name="aFor">The ID of the form element this label is associated with.</param>
    function OpenLabel(aFor: string): IHTMLWriter; overload;
    /// <summary>Opens a &lt;select&gt; tag with a name attribute.</summary>
    /// <param name="aName">The name attribute value for the select element.</param>
    /// <remarks>This method can only be called inside a &lt;form&gt; tag.</remarks>
    function OpenSelect(aName: string): IHTMLWriter;
    /// <summary>Opens an &lt;option&gt; tag.</summary>
    /// <remarks>This method can only be called inside a &lt;select&gt; tag.</remarks>
    function OpenOption: IHTMLWriter;
    ///	<summary>Creates and opens a &lt;textarea&gt; tag.</summary>
    ///	<param name="aName">A unique identifier given to the tag.</param>
    ///	<param name="aText">The text to be added inside the &lt;textarea&gt; tag.</param>
    function OpenTextArea(aName: string; aCols: integer; aRows: integer): IHTMLWriter;
    /// <summary>Opens an &lt;optgroup&gt; tag with a label attribute.</summary>
    /// <param name="aLabel">The label for the option group.</param>
    /// <remarks>This method can only be called inside a &lt;select&gt; tag.</remarks>
    function OpenOptGroup(aLabel: string): IHTMLWriter;
    /// <summary>Opens a &lt;fieldset&gt; tag.</summary>
    function OpenFieldSet: IHTMLWriter;
    /// <summary>Opens a &lt;legend&gt; tag.</summary>
    /// <remarks>This method will raise an exception if called outside of an open &lt;fieldset&gt; tag.</remarks>
    function OpenLegend: IHTMLWriter;
    /// <summary>Adds the passed in text to a &lt;legend&gt;&lt;/legend&gt; tag</summary>
    /// <param name="aText">The text to be included in the Legend tag.</param>
    function AddLegend(aText: string): IHTMLWriter;
    /// <summary>Opens an &lt;iframe&gt; tag.</summary>
    function OpenIFrame: IHTMLWriter; overload;
    /// <summary>Opens an &lt;iframe&gt; tag and adds a url parameter</summary>
    /// <param name="aURL">The value to be added with the url parameter.</param>
    function OpenIFrame(aURL: string): IHTMLWriter; overload;
    /// <summary>Opens an &lt;iframe&gt; tag with URL, width, and height attributes.</summary>
    /// <param name="aURL">The URL to be displayed in the iframe.</param>
    /// <param name="aWidth">The width of the iframe.</param>
    /// <param name="aHeight">The height of the iframe in pixels.</param>
    function OpenIFrame(aURL: string; aWidth: THTMLWidth; aHeight: integer): IHTMLWriter; overload;
    /// <summary>Adds a complete &lt;iframe&gt;&lt;/iframe&gt; tag with a URL and alternate text.</summary>
    /// <param name="aURL">The URL to be displayed in the iframe.</param>
    /// <param name="aAlternateText">The text displayed if the iframe cannot be rendered.</param>
    function AddIFrame(aURL: string; aAlternateText: string): IHTMLWriter; overload;
    /// <summary>Adds a complete &lt;iframe&gt;&lt;/iframe&gt; tag with URL, alternate text, width, and height.</summary>
    /// <param name="aURL">The URL to be displayed in the iframe.</param>
    /// <param name="aAlternateText">The text displayed if the iframe cannot be rendered.</param>
    /// <param name="aWidth">The width of the iframe.</param>
    /// <param name="aHeight">The height of the iframe in pixels.</param>
    function AddIFrame(aURL: string; aAlternateText: string; aWidth: THTMLWidth; aHeight: integer): IHTMLWriter; overload;
    /// <summary>Opens an unordered list tag (&lt;ul&gt;)</summary>
    /// <param name="aBulletShape">An optional parameter indicating the bullet type that the list should use.</param>
    /// <seealso cref="TBulletShape">TBulletShape</seealso>
    function OpenUnorderedList(aBulletShape: TBulletShape = bsNone): IHTMLWriter;
    /// <summary>Opens an ordered list tag (&lt;ol&gt;)</summary>
    /// <param name="aNumberType">An optional parameter indicating the numbering type that the list should use.</param>
    /// <seealso cref="TNumberType">TNumberType</seealso>
    function OpenOrderedList(aNumberType: TNumberType = ntNone): IHTMLWriter;
    /// <summary>Opens a list item (&lt;li&gt;) inside of a list.</summary>
    function OpenListItem: IHTMLWriter;
    /// <summary>Adds a List item (&lt;li&gt;) with the given text</summary>
    /// <param name="aText">The text to be added to the list item.</param>
    function AddListItem(aText: string): IHTMLWriter;
    ///	<summary>Opens a &lt;frameset&gt; tag.</summary>
    ///	<remarks>This tag is not part of the HTML5 specification.</remarks>
    function OpenFrameset: IHTMLWriter;
    /// <summary>Opens a &lt;frame&gt; tag.</summary>
    /// <exception cref="ENotInFrameSetHTMLException">Raised if this is called outside of a &lt;frameset&gt;
    /// tag.</exception>
    ///	<remarks>This tag is not part of the HTML5 specification.</remarks>
    function OpenFrame: IHTMLWriter;
    /// <summary>Opens a &lt;noframes&gt; tag.</summary>
    ///	<remarks>This tag is not part of the HTML5 specification.</remarks>
    function OpenNoFrames: IHTMLWriter;
    /// <summary>Opens a &lt;map /&gt; tag</summary>
    function OpenMap: IHTMLWriter;
    /// <summary>Opens an &lt;area /&gt; tag</summary>
    function OpenArea(aAltText: string): IHTMLWriter;
    /// <summary>Opens an &lt;object&gt; tag</summary>
    function OpenObject: IHTMLWriter;
    /// <summary>Opens a &lt;param&gt; tag</summary>
    /// <param name="aName">The name for the parameter</param>
    /// <param name="aValue">The value to be assigned to the paramter</param>
    /// <remarks>This tag can only be used inside of an &lt;object&gt; tag.</remarks>
    /// <exception cref="ENotInObjectTagException">Raised if this method is called outside of an &lt;object&gt;
    /// tag</exception>
    function OpenParam(aName: string; aValue: string = ''): IHTMLWriter; // name parameter is required

    /// <summary>Opens a &lt;dl&gt; (definition list) tag.</summary>
    function OpenDefinitionList: IHTMLWriter;
    /// <summary>Opens a &lt;dt&gt; (definition term) tag.</summary>
    /// <remarks>This method can only be called inside a &lt;dl&gt; tag.</remarks>
    function OpenDefinitionTerm: IHTMLWriter;
    /// <summary>Opens a &lt;dd&gt; (definition item) tag.</summary>
    /// <remarks>This method can only be called after a &lt;dt&gt; or another &lt;dd&gt; tag.</remarks>
    function OpenDefinitionItem: IHTMLWriter;

    // HTML5 Semantic Structure Elements
    /// <summary>Opens an &lt;article&gt; tag.</summary>
    function OpenArticle: IHTMLWriter;
    /// <summary>Adds the passed in text inside an &lt;article&gt;&lt;/article&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the article tag.</param>
    function AddArticleText(aString: string): IHTMLWriter;
    /// <summary>Opens an &lt;aside&gt; tag.</summary>
    function OpenAside: IHTMLWriter;
    /// <summary>Adds the passed in text inside an &lt;aside&gt;&lt;/aside&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the aside tag.</param>
    function AddAsideText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;details&gt; tag.</summary>
    function OpenDetails: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;details&gt;&lt;/details&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the details tag.</param>
    function AddDetailsText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;figcaption&gt; tag.</summary>
    function OpenFigCaption: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;figcaption&gt;&lt;/figcaption&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the figcaption tag.</param>
    function AddFigCaptionText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;figure&gt; tag.</summary>
    function OpenFigure: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;figure&gt;&lt;/figure&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the figure tag.</param>
    function AddFigureText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;footer&gt; tag.</summary>
    function OpenFooter: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;footer&gt;&lt;/footer&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the footer tag.</param>
    function AddFooterText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;header&gt; tag.</summary>
    function OpenHeader: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;header&gt;&lt;/header&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the header tag.</param>
    function AddHeaderText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;main&gt; tag.</summary>
    function OpenMain: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;main&gt;&lt;/main&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the main tag.</param>
    function AddMainText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;nav&gt; tag.</summary>
    function OpenNav: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;nav&gt;&lt;/nav&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the nav tag.</param>
    function AddNavText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;section&gt; tag.</summary>
    function OpenSection: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;section&gt;&lt;/section&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the section tag.</param>
    function AddSectionText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;summary&gt; tag.</summary>
    function OpenSummary: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;summary&gt;&lt;/summary&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the summary tag.</param>
    function AddSummaryText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;dialog&gt; tag.</summary>
    function OpenDialog: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;dialog&gt;&lt;/dialog&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the dialog tag.</param>
    function AddDialogText(aString: string): IHTMLWriter;

    // HTML5 Text-Level Semantic Elements
    /// <summary>Opens a &lt;mark&gt; tag.</summary>
    function OpenMark: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;mark&gt;&lt;/mark&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the mark tag.</param>
    function AddMarkText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;bdi&gt; tag.</summary>
    function OpenBdi: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;bdi&gt;&lt;/bdi&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the bdi tag.</param>
    function AddBdiText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;ruby&gt; tag.</summary>
    function OpenRuby: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;ruby&gt;&lt;/ruby&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the ruby tag.</param>
    function AddRubyText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;rt&gt; tag.</summary>
    function OpenRt: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;rt&gt;&lt;/rt&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the rt tag.</param>
    function AddRtText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;rp&gt; tag.</summary>
    function OpenRp: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;rp&gt;&lt;/rp&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the rp tag.</param>
    function AddRpText(aString: string): IHTMLWriter;
    /// <summary>Opens a &lt;time&gt; tag.</summary>
    function OpenTime: IHTMLWriter;
    /// <summary>Adds the passed in text inside a &lt;time&gt;&lt;/time&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the time tag.</param>
    function AddTimeText(aString: string): IHTMLWriter;
    /// <summary>Opens an &lt;output&gt; tag.</summary>
    function OpenOutput: IHTMLWriter;
    /// <summary>Adds the passed in text inside an &lt;output&gt;&lt;/output&gt; tag.</summary>
    /// <param name="aString">The text to be added inside the output tag.</param>
    function AddOutputText(aString: string): IHTMLWriter;
    /// <summary>Adds a &lt;wbr /&gt; tag.</summary>
    function AddWordBreak: IHTMLWriter;

    // HTML5 Media Elements
    /// <summary>Opens an &lt;audio&gt; tag.</summary>
    function OpenAudio: IHTMLWriter; overload;
    /// <summary>Opens an &lt;audio&gt; tag with a src attribute.</summary>
    /// <param name="aSource">The URL of the audio source.</param>
    function OpenAudio(aSource: string): IHTMLWriter; overload;
    /// <summary>Opens a &lt;video&gt; tag.</summary>
    function OpenVideo: IHTMLWriter; overload;
    /// <summary>Opens a &lt;video&gt; tag with a src attribute.</summary>
    /// <param name="aSource">The URL of the video source.</param>
    function OpenVideo(aSource: string): IHTMLWriter; overload;
    /// <summary>Opens a &lt;video&gt; tag with src, width, and height attributes.</summary>
    /// <param name="aSource">The URL of the video source.</param>
    /// <param name="aWidth">The width of the video in pixels.</param>
    /// <param name="aHeight">The height of the video in pixels.</param>
    function OpenVideo(aSource: string; aWidth: integer; aHeight: integer): IHTMLWriter; overload;
    /// <summary>Opens a &lt;source&gt; tag (void element).</summary>
    function OpenSourceElement: IHTMLWriter;
    /// <summary>Adds a &lt;source /&gt; tag with src and type attributes.</summary>
    /// <param name="aSource">The URL of the media source.</param>
    /// <param name="aType">The MIME type of the media source.</param>
    function AddSourceElement(aSource: string; aType: string): IHTMLWriter;
    /// <summary>Opens a &lt;track&gt; tag (void element).</summary>
    function OpenTrack: IHTMLWriter;
    /// <summary>Opens a &lt;canvas&gt; tag.</summary>
    function OpenCanvas: IHTMLWriter; overload;
    /// <summary>Opens a &lt;canvas&gt; tag with width and height attributes.</summary>
    /// <param name="aWidth">The width of the canvas in pixels.</param>
    /// <param name="aHeight">The height of the canvas in pixels.</param>
    function OpenCanvas(aWidth: integer; aHeight: integer): IHTMLWriter; overload;

    // HTML5 Attribute Helpers
    /// <summary>Adds a role="" attribute to the current tag.</summary>
    /// <param name="aRole">The WAI-ARIA role value.</param>
    function AddRole(aRole: string): IHTMLWriter;
    /// <summary>Adds a data-{aName}="{aValue}" custom data attribute to the current tag.</summary>
    /// <param name="aName">The data attribute name (without the "data-" prefix).</param>
    /// <param name="aValue">The data attribute value.</param>
    function AddDataAttribute(aName: string; aValue: string): IHTMLWriter;
    /// <summary>Adds an aria-{aName}="{aValue}" accessibility attribute to the current tag.</summary>
    /// <param name="aName">The ARIA attribute name (without the "aria-" prefix).</param>
    /// <param name="aValue">The ARIA attribute value.</param>
    function AddAriaAttribute(aName: string; aValue: string): IHTMLWriter;
    /// <summary>Adds a placeholder="" attribute to the current tag.</summary>
    /// <param name="aPlaceholder">The placeholder text to display.</param>
    function AddPlaceholder(aPlaceholder: string): IHTMLWriter;

    // HTML5 Boolean Attribute Helpers
    /// <summary>Adds the required boolean attribute to the current tag.</summary>
    /// <remarks>Produces a bare "required" attribute with no value.</remarks>
    function AddRequired: IHTMLWriter;
    /// <summary>Adds the disabled boolean attribute to the current tag.</summary>
    /// <remarks>Produces a bare "disabled" attribute with no value.</remarks>
    function AddDisabled: IHTMLWriter;
    /// <summary>Adds the autofocus boolean attribute to the current tag.</summary>
    /// <remarks>Produces a bare "autofocus" attribute with no value.</remarks>
    function AddAutofocus: IHTMLWriter;
    /// <summary>Adds the hidden boolean attribute to the current tag.</summary>
    /// <remarks>Produces a bare "hidden" attribute with no value.</remarks>
    function AddHidden: IHTMLWriter;
    /// <summary>Adds the readonly boolean attribute to the current tag.</summary>
    /// <remarks>Produces a bare "readonly" attribute with no value.</remarks>
    function AddReadonly: IHTMLWriter;
    /// <summary>Adds the multiple boolean attribute to the current tag.</summary>
    /// <remarks>Produces a bare "multiple" attribute with no value.</remarks>
    function AddMultiple: IHTMLWriter;
    /// <summary>Adds the novalidate boolean attribute to the current tag.</summary>
    /// <remarks>Produces a bare "novalidate" attribute with no value.</remarks>
    function AddNovalidate: IHTMLWriter;

    // HTML5 Additional Elements
    /// <summary>Opens a &lt;picture&gt; tag.</summary>
    function OpenPicture: IHTMLWriter;
    /// <summary>Adds a &lt;picture&gt; tag containing an &lt;img&gt; child element with src and alt attributes.</summary>
    /// <param name="aImageSrc">The URL of the image source.</param>
    /// <param name="aAltText">The alternative text for the image.</param>
    function AddPictureImg(aImageSrc: string; aAltText: string): IHTMLWriter;
    /// <summary>Opens a &lt;template&gt; tag.</summary>
    function OpenTemplate: IHTMLWriter;
    /// <summary>Opens an &lt;embed&gt; tag (void element).</summary>
    function OpenEmbed: IHTMLWriter;
    /// <summary>Adds an &lt;embed /&gt; tag with src and type attributes.</summary>
    /// <param name="aSource">The URL of the embedded content.</param>
    /// <param name="aType">The MIME type of the embedded content.</param>
    function AddEmbed(aSource: string; aType: string): IHTMLWriter;

    // HTML5 Convenience Combo Methods
    /// <summary>Adds a &lt;figure&gt; containing an &lt;img&gt; and &lt;figcaption&gt;.</summary>
    /// <param name="aImageSrc">The URL of the image source.</param>
    /// <param name="aCaptionText">The text for the figcaption element.</param>
    function AddFigure(aImageSrc: string; aCaptionText: string): IHTMLWriter;
    /// <summary>Adds a &lt;details&gt; containing a &lt;summary&gt; and detail text.</summary>
    /// <param name="aSummaryText">The text for the summary element.</param>
    /// <param name="aDetailsText">The detail text content.</param>
    function AddDetailsSummary(aSummaryText: string; aDetailsText: string): IHTMLWriter;

    // HTML5 Form Elements
    /// <summary>Opens a &lt;datalist&gt; tag.</summary>
    function OpenDatalist: IHTMLWriter;
    /// <summary>Opens a &lt;progress&gt; tag.</summary>
    function OpenProgress: IHTMLWriter; overload;
    /// <summary>Opens a &lt;progress&gt; tag with value and max attributes.</summary>
    /// <param name="aValue">The current progress value.</param>
    /// <param name="aMax">The maximum value.</param>
    function OpenProgress(aValue: integer; aMax: integer): IHTMLWriter; overload;
    /// <summary>Opens a &lt;meter&gt; tag.</summary>
    function OpenMeter: IHTMLWriter; overload;
    /// <summary>Opens a &lt;meter&gt; tag with value, min, and max attributes.</summary>
    /// <param name="aValue">The current meter value.</param>
    /// <param name="aMin">The minimum value.</param>
    /// <param name="aMax">The maximum value.</param>
    function OpenMeter(aValue: integer; aMin: integer; aMax: integer): IHTMLWriter; overload;

    property Attribute[const Name: string; const Value: string]: IHTMLWriter read GetAttribute; default;
    ///	<summary>Property determining the level of error reporting that the class should provide.</summary>
    property ErrorLevels: THTMLErrorLevels read GetErrorLevels write SetErrorLevels;
    property HTML: TStringBuilder read GetHTML;
end;

implementation

end.