This is the website for the the Muster Markup language (previously called the Simplewiki Markup language) specification, and the parser/emitter PHP5 module.
For an example of what the markup looks like, view the source markup for this page.
These are the basic characteristics of Muster Markup:
Muster Markup starts with the creole markup set for basic markup, then adds decorators for the basic markup (both inline decorators and block decorators) and very concise tag declarations for all block and inline html5 elements, for advanced markup. Muster Markup also supports macros.
Basic markup allows users to post articles with the usual simple and concise markup for headings, paragraphs, bold, italics, images, links, lists, quick tables, etc..
What makes Muster Markup unique (as far as we know) is the thin veneer over HTML and CSS provided for more advanced markup through consistent formats of decoration arguments passed to markup objects through decorators. Decorators provide a uniform way of applying classes, style-rules, and attributes to the objects created by simplewiki's basic markup.
Decoration arguments, whether for decorators or tag declarations, are always in one of three formats:
| Format: | Discreet-value format | Colon-separated format | Equals-separated format | |||
|---|---|---|---|---|---|---|
| Interpretation: | class | style rule | attribute | |||
| Example: | :table standard: | %i border:'2px solid green'% | :td colspan=2: | |||
| Action: | block decorator: add class "standard" to the class attribute of the quick table | inline decorator: place a border around an image | block decorator: make the current cell span two columns | |||
| Result: | adds class to underlying HTML element's class attribute | adds style rule to underlying HTML element's style attribute | passes attribute as-is to underlying HTML element |
Any number of each decorator argument formats, in any appropriate combination, can be passed through decorators or tag declarations to markup objects. So these decorations allow any number of classes, styles, or attributes to be passed to the markup objects, and ultimately the generated html elements.
In this way Muster Markup can act as a thin skin over HTML, which is very easy to maintain. In other words it can be the basis of a CMS (content management system), without having to invent new markup syntax for every new required element.
The Muster Markup module (called SimpleWiki) also supports tag declarations for things like advanced div, blockquote, table and list work. Block declarations can be nested. Block and inline declarations support most available html5 tags, and can be extended. It is perfect to write on the darknet tor
For behavioural extensions, Muster Markup also supports macros. Furthermore class and property names can be registered by client software as methods (action classes and action properties), and interpreted in interesting ways (for example "footnote"). Class and property methods, macros, tag declarations, symbolic links, and certain events can all be extended through client add-ins and handlers.
The SimpleWiki module (which implements the Muster Markup Language) is available for free, as open-source software, under the BSD licence.
The markup language specification has six parts:
|
------- | -------
Special Character patterns | All special character patterns used to markup text - basic shortcuts
Link and Image URI formats | Network protocol, symbolic link, and anchor formats of reference to links and images - shortcuts
Decorators | The special inline decorator and block decorator markup, and selectors available - shortcuts for decoration arguments: classes, attributes, and styles
Tag Declarations | The special tag declarations, and selectors available - other html formats
Decoration argument formats | The standard decoration argument formats used to pass data to underlying html elements through decorators and declarations
Macros | General markup available for client-defined macro procedures. The language specification does not define any macros
Marking up content so that it will look good involves using a few special characters (like forward slashes //emphasis// for emphasis, and a lot of decorators. Decorators are sequences of characters that provide detailed style information to the markup engine. The core of the language is creole 1.0. Decorators and Declarations (and a few other things) are extensions.
SimpleWiki Special Character Patterns Character Pattern Usage Description Basic markup - common shortcuts = heading equals signs, 1 to 6 of them, start of line paragraph blank line above text // ... // emphasis (italic) 2 forward slash pairs, open and close ** ... ** strong (bold) 2 asterisk pairs, open and close ---- horizontal rule four dashes, alone on line Basic markup - occasional shortcuts \ line break 2 inline backslashes ~ escape character tilde; the following character will be parsed as literal `` line continuation 2 backticks start of line, to make the source more readable - these are stripped out during parsing
Links and Images shortcuts [[...|...|...]] link; caption and title optional opening and closing double square brackets; optional one or two vertical bars [[#...|...|...]] anchor link; caption required, title optional opening double square brackets and hash mark, closing double square brackets; optional one or two vertical bars [[#...]] anchor target opening double square brackets and hash mark, closing double square brackets {{...|...|...}} image; caption and title optional opening and closing double braces; optional one or two vertical bars Lists and Tables shortcuts * ** unordered list asterisk - one at start of first line; one or more, nested, on following lines[1] # ## ordered list hash mark - one at start of first line; one or more, nested, on following lines : ... :: ... :: ... :: ... definition list colon - one at start of first line; one or more, nested, on following lines; the embedded double colon denotes the end of the term and the start of the description, and is optional. Without the double colon the text is the description. |...|...|...| etc. |...|...|...| etc. quick table row vertical bars - beginning at start of line, plus one for each additional cell, plus closing vertical bar; multiple lines |= heading cell (th) "=" following vertical bar in table row Decorators - shortcuts for classes, styles, and attributes % ... % inline decorator opening and closing percent sign, containing selector and decoration arguments, inline %% end-of-span-decoration two percent signs, inline usage: %s ...%...%% |: ... :| block decorator opening and closing mirrored vertical bar and colon, containing selector and decoration arguments, start of line Advanced - tag declarations for other html shortcuts [\t\x20]*(:? ... :) ... [\t\x20]*(:?end:) block tag declaration opening tag at start of a line, containing tagname and decoration arguments; closing tag alone on a later line; ?=tag name; [\t\x20]*=tab/space-chars (optional) for nesting and must match as to count of characters; end signifies closing tag %=? ... % ... %=% inline tag declaration opening %= anywhere in the line, containing tagname and decoration arguments; closing markup %=% (optional) before the end of the line if only part of the line is to be marked; ? = tagname [\t\x20]*(::? ... :) void block tag declaration - opening tag only; no content opening tag at start of a line, containing tagname and decoration arguments; ?=tag name;[\t\x20]*=tab/space-chars (optional) %==? ... % void inline tag declaration - opening tag only; no content opening %== anywhere in the line, containing tagname and decoration arguments; ? = tagname Advanced - other specialized markup << ... | ... >> macro, text optional opening and closing angle brackets, containing macro name and decoration arguments, optional vertical bar followed by parsed inline text {{{...}}} inline preformatted text opening and closing triple braces, containing performatted text {{{ ... }}} preformatted block opening triple braces alone on a line, closing triple braces alone on later line; preformatted text in between ```## metadata 3 backticks followed by two hash marks - first line, followed by arguments interpreted by client software; obtained with $dataobject = $wiki->get_metadata(); {{##? ... ##}} marker ?=name. Markers are extracted and marker objects are listed in an array that can be obtained with $wiki->markerdata() after $wiki->prepare(). Each marker object contains the marker name, its offset, and its decoration. symlink version marker (backtick) after a symlink selector for either an image or a link Symlink:selector`version, a backtick followed by a name can be used by a registered symlink handler to find a version of a file. Useful for image sizes for example. Note that ordered and unordered lists can be nested within each other. ## Link and Image URI Formats The first cell of Link and Image markups consist of a url to the link or image. For links the format can be any one of the three; for images the format can be protocol or symbolic. Format Name Format Structure Notes Network Protocol Format protocol://address standard url format: http, https, ftp, nntp, news, mailto, telnet, file, irc Symbolic Link Format Symlink:selector symbolic links registered by client software; special link Local: is registered by SimpleWiki by default for relative directory addressing; Anchor: is also a default; first character of Symlink must be capitalized Anchor Format #selector key symbolic link 'Anchor' can be registered to deal with html base issues if needed; set target element id attribute to selector Raw link format selector When none of the above are recognized, the raw link is available to be passed to a client-registered raw link handler for interpretation The special symbolic links Local: and Anchor: are registered by default by the SimpleWiki module. Local is intended to allow relative directory addressing for local references. Anchor is intended to allow on-page links. See the Module section for details on registering symbolic links, symbolic link handlers, and raw link handlers with SimpleWiki. In addition, free standing http, https, and mailto addresses will automatically have link markup [[ ... ]] wrapped around them. Other protocols (such as ftp) must escape the forward slashes in the format (like ftp:~//someaddress), or the forward slashes will be interpreted as emphasis markup. Decorators Decorators provide a uniform way of applying style classes, style-rules, and attributes to the objects created by the basic markup. They provide a thin (and simplified) veneer over HTML. There are two kinds of decorators: inline decorators, and block decorators. Inline decorators begin and end with a percent sign %inlinedecorator%, and block decorators begin and end with a mirrored pair of characters (the vertical bar and colon) like this |:blockdecorator:|. All decorators have to be placed right in front of the opening markup for the objects they decorate. Within their delimiters, inline and block decorators have identical markup structures: %selector decoration_arguments% |:selector decoration_arguments:| The selector tells the markup engine what object type the decoration is applied to, and the decoration arguments convey the information about what to apply. Inline Decorators There are only four types of inline decorators: SimpleWiki Inline Decorators Selector Target object Notes Example s span in front of a sequence of words, closed with %% %s underline%...%% l link (l=lower case "L") in front of [[link]] %l newwin%[[... i image in front of {{image}} %i rframe%{{... c code in front of preformatted text {{{text}}} %c html%{{{... Note that the closing markup of two percent signs %% closes the scope of the span (%s ...%) decoration. Block Decorators There are quite a few block decorators: SimpleWiki Block Decorators Selector Target object Example Paragraph p paragraph |:p font-weight:bold:|... Dividers h heading |:h section-divider-high:|===... b empty block (divider)[2] |:b spacer dots:| Lists ul unordered list |:ul list-style-type:square:|* ... ol ordered list |:ol list-style-type:upper-roman start="10":|# ... li list item |:li font-style:italic:|# ... |:ul list-style-type:square:||:li font-style:italic:|* ... dl definition list |:dl ... :|: ... dt definition term |:dt ... :|: ... dd definition description |:dd ... :|: ... |:dl ... :||:dt ... :||:dd ... :|: ... Tables table table |:table border="1":||...|...|... tr table row |:tr background-color:yellow:||...|...|... |:table border="1":||:tr background-color:yellow:||...|...|... th table heading cell color green applied to second from left cell: |=...|:th color:green:||=...|=... three decorators applied to the same line: |:table border="1":||:tr background-color:yellow:| ``|:th color:green:||=...|=...|=... td table data cell |...|:td color:green:||...|... td decorator usage is identical to th decorator usage Preformatted Text pre preformatted text block |:pre html:|{{{ ... Block decorators must be placed immediately in front of the objects that they decorate. Block dividers are placed on a line by themselves (the block object for block dividers is implicit). When more than one block decorator is placed in front of an object (like |:table... and |:tr... in front of the same vertical bar), they must be placed in order, from outer object to inner object (for example table block decorator before table row block decorator). Tag Declarations The markup supports four kinds of tag declarations: block, void block, inline and void inline. "void" means an opening tag only, with no content. The markup summary is: (:selector decoration_arguments:) content // block element more content (:selectorend:) (::selector decoration_arguments:) // void block element %=selector decoration_arguments% content %=% // inline element %==selector decoration_arguments% // void inline element This markup not only avoids limitations for the sophisticated author, but also supports brevity and consistency of markup. See Tag Def Extensions for ways of getting and setting the set of tags that your client software can control. Block Tag Declarations block declarations Markup Tag Meaning HTML Tag content blocks div generic division div blockquote indented block of content blockquote table table table table caption caption caption thead table head thead tbody table body tbody tfoot table footer tfoot tr table row tr td table data cell td th column header cell th colgroup column group colgroup col column (but use void version instead) col lists ul unordered list ul ol ordered list ol li list item li dl definition list dl dt definition term dt dd definition description dd dlml (website - deprecated) dlwidget dlml widget dl:widget dlsettings dlml settings dl:settings dlmodule dlml module dl:module dlmarker dlml marker (reserved) dl:marker For advanced page layout design, the markup provides block declarations. These are a thin veneer over html. The general syntax for block declarations is <tab-or-space-char>*(:tagname decoration_arguments:) ... <tab-or-space-char>*(:tagnameend:) The tagname is required, and must be one of the tagnames listed in the tables at the right or below. Both opening and closing tags must be at the start of the line. Closing tags must be alone on a line. Opening tags can have content following on the same line to avoid generation of a paragraph block. The <tab-or-space-char>'s are optional, but are available to allow nesting of blocks, like this: (:div background-color:red:) some content (:div margin:20px bacground-color:green:) some more content (:divend:) (:divend:) ... where the indents are matching numbers of tab or space characters. The blocks can be nested in any combination to any (logical) depth. This allows, for example, complex tables inside table cells. The decoration arguments are optional, but are available to set style classes, style rules, or attributes of the underlying HTML element. Action classes are also available (see below). Each declared block (and nested declared block) is parsed as a block of content, and so can contain any of the markup structures made available, like quick tables, lists, etc. The tags available for block declarations are listed at the right and below. more block declarations Markup Tag = HTML Tag Meaning Markup Tag = HTML Tag Meaning HTML 5 semantic tags media tags figure embedded figure map figcaption figure caption object also allowed as inline tag article self-contained content audio address content author address video aside related sidebar canvas footer page footer form tags section document section form header page header output hgroup header group datalist nav navigation section muster widget tags main main content reserved details a disclosure widget mw-module dialog popup dialog mw-widget summary summary of details mw-settings HTML 5 ruby tags mw-marker ruby ruby annotation (East Indian languages) muster widgets is a javascript library planned by the author of this markup rt explanation of ruby characters rp ruby base text Inline Tag Declarations Inline tag declarations are markup for inline tags: some content %=tagname decoration_arguments%some content%=% <- closing markup for inline tags The following tags are supported (natively). Tags are filtered at compile time according to this list. If a tag is used that is not supported, the raw markup is output instead. inline tag declarations Markup Tag = HTML Tag Meaning Markup Tag = HTML Tag Meaning appearance specialized b bold a anchor i italic img image big q quote small span ins button del progress abbr meter cite time sub subscript object embedded sup superscript bdi bi-directional isolation mark bdo bi-directional over-ride phrase elements form code select dfn definition option for select em emphasis label strong textarea kbd keyboard misc samp sample code command command button html5 var variable Void Block Tag Declarations Void tag declarations allow void tags (single tag - no content) markup. (::tagname decoration_arguments:) hr horizontal rule area for map param for object source for audio track for video col col spec for colgroup Void Inline Tag Declarations Void tag declarations allow void tags (single tag - no content) markup. %==tagname decoration_arguments% br line break wbr word break (html5) img image input form keygen form embed container for external application Decorator and Tag Declaration Decoration Argument Formats Decoration arguments are the data values that are passed from the Decorators and Tag Declarations to the target objects (meaning the underlying HTML elements). The decoration arguments for all decorators and tag declarations have the same structure. There are exactly three formats of argument available in all cases: Argument Format Description Target textvalue (class name) discreet textual value single name containing a character, followed by characters, numerals, underscore (_), or dash(-) HTML element class attribute property (style rule) colon-separated rulename: rulevalue rulename follows classname rules; rulevalue always separated by colon (:); rulevalue can be surrounded by single or double quotes HTML element style attribute attribute equals-separated attributename= attributevalue attributename follows classname rules; attribute value always separated by an equals sign; attributevalue can be surrounded by single or double quotes HTML element named attribute There can be zero to many instances of each format of decoration argument, but for Decorators (not for Tag Declarations) there must be at least one decoration argument. Classnames (unless they are registered action classes -- see below) are passed directly to the target object's (underlying HTML element) class attribute. When classnames are directly passed through like this they are called style classes. Style rules (unless they are registered action properties are passed directly to the target object's style attribute. Attributes are passed directly to the underlying target objects as is. Note that the attributes value delimiter that is written by the author is preserved in html generation. This allows JSON arguments to be used for custom attributes. In this way, SimpleWiki can be viewed as a thin (simplifying) skin over the HTML layer of the web page. Style classes are any classes defined in css (cascading style sheet) files that are created for the website. Style classes are named collections of style rules. Action classes are any classnames (registerd as methods by the client application using SimpleWiki) that perform software-based operations on the underlying HTML elements. SimpleWiki contains a number of native action classes. Action classes serve as automation shortcuts to achieve desired effects. Action properties are analagous to action classes (propertymethod:methodarguments) except their format allows passing of arguments to the methods. Property methods are also registered by client software, and should be unset as html properties during processing to prevent them from being interpreted natively as styles. Style rules can be any valid CSS style rules. Attributes can be any valid attributes for the target's underlying HTML element. It is a generally accepted best practice to rely on logically named style classes as much as possible, to allow for centralized revision of style schemes. The corollary is to avoid explicit style rules as much as possible. In most cases, styling options available through attributes are better implemented using css style rules. Macros Macros are registered by client software, and interpreted by callback functions. Macro syntax allows for the macroname, arguments in standard formats, and parsed inline markup to the right of a vertical bar. How these resources are used is up to the callback function. See the Module section for details. The SimpleWiki module registers one macro by default: quicktoc. This macro uses any markup title as the quick table of contents header, if present (otherwise uses the string "Table of contents"). Footnotes: ^[1] The first list item in a list must have only one star or hashmark. This is to avoid conflict with the two-star strong markup ^[2] The b decorator is for an empty block, and must be alone on a line. To create a div use |:p div:| ("change paragraph into div") instead, or use the (:div...:) block declaration SimpleWiki Extensions view source markup posted November 21, 2009; updated June 18, 2011 Overview There are a number of ways to extend the SimpleWiki Markup Language. Indeed the SimpleWiki Module includes many native extensions. Extension Method Applies to Description Style Classes decorators, declarations any appropriate class (as made available through .css files) can be passed to the underlying object's class attribute Style rules decorators, declarations any appropriate style rule can be passed to the underlying object's style attribute Attributes decorators, declarations Any appropriate attribute can be passed to the underying object Action Classes and Properties decorators, declarations Class names and property names trigger calls to registered client callback functions before emitting, which can then emit interesting html, or perform operations on the parsed document object model. The SimpleWiki module currently provides several of these, notably the span decorator action class footnote Macros client source code - PHP Macros must be provided and registered by client source code - PHP. The SimpleWiki module currently provides the quicktoc macro Symbolic Links links, images format: [[Symlink:selector | ... ]] or {{Symlink:selector | ... }}. Client software registers symlinks and their replacement paths, or provides a callback routine (handler) to look them up Raw Links links, images format: [[rawlink | ... ]] or {{rawlink | ... }}. For links that aren't anchors, external links (with recognized protocols), or symlinks, client software can provide a callback routine (handler) to interpret the raw link. For example for classic single-term wiki links. Events client source code - PHP The SimpleWiki module currently defines two events: onemit and onafteremit Tag Defs client source code - PHP Client software can register a tag def handler (block or inline tags, or block or inline void - single - tags), which can authorize any block or inline tag, and manipulate tag def node data. Client source code can also change the set of tags allowed by the markup Character filters client source code - PHP Client software can register a charfilter handler, when an alternate filter to htmlspecialchars(...) is desired. Style Classes A number of commonly used style classes are provided with the implementation module in SimpleWiki.css (Native Style Classes). In addition websites can (and should) provide their own. For example we have framework.css and content.css files. Style Rules Any appropriate style rules in the format rulename:rulevalue can be added to any decorator or block declaration argument. Rule values can be delimited with single or double quotes if required. [1] Attributes Any appropriate attribute in the format atributename=attributevalue can be added to any decorator or block declaration argument. Single or double quote delimiters can be added to attributevalue in order to group values containing spaces. If no quotes are used then SimpleWiki adds them during html emitting.[2] Action Classes and Properties Action classes and properties are software processes that modify the underlying HTML in some way. More can be added by client software (see Module for details). Here are the action classes defined natively for SimpleWiki: Element Classname Effect Span %s subscript% subscript change span element to sub element %s superscript% superscript change span element to sup element %s footnote% footnote create a footnote, with on-page sequentially numbered links to and from the footnote %s comment% comment create an in-line comment, which is stripped out when rendering Link %l newwin% newwin open the following link in a new window Image %i lframe% lframe wrap the image in a div and float left %i rframe% rframe wrap the image in a div and float right Paragraph |:p nop:| nop (no paragraph) prevents generation of enclosing paragraph html tags |:p div:| div creates an enclosing div element instead of paragraph element Block Declaration (:div frame:) frame create frame appearance (:div lframe:) lframe create frame appearance and float left (:div rframe:) rframe create frame appearance and float right Preformatted |:pre html:|{{{ html contents of preformatted block treated as HTML %c html%{{{ html contents of inline preformatted text treated as HTML Macros Macros have to be written and registered by client software. Simplewiki provides one macro - quicktoc - which generates a page table of contents from page headings. Macro syntax is <<macroname arguments | parsed-inline-markup>> The macroname is required, but arguements and parset-inline-markup are optional (depending on the requirements of the macro). For quicktoc, there are no arguments. parsed-inline-markup, if provided, is used as the table of contents header (otherwise the caption "Table of contents" is used). Symbolic Links Symbolic links are one of the ways to referece links or images (see Symbolic Links in the language definition). The format is: Symlink:selector Two symlinks are predefined: Local and Anchor, and both, by default are empty. Local is provided for relative directory addressing. Anchor is provided for on-page links ([[#anchorname|anchor text]]). Either can be over-ridden by the client software. Client software can register its own symbolic links, or indeed a callback function to lookup value for any symbolic link used by authors. See Module for details. Raw Links Raw links are links that have not been parsed as anchors, external links (with the recognized protocols http, https, mailto), or symlinks. Client software can intercept these and substitute valid html links. For example this would allow users to write classic one-term wiki links: [[WikiLink|some other wiki page]]. Events There are currently two events defined by SimpleWiki: onemit and onafteremit. These are for specialized requirements. For example SimpleWiki provides for a method that can be registered with onemit to automatically generate quick tables of content for all pages (see Module for details). The footnote action class uses the onafteremit event to generate footnotes at the end of a document. Tag Defs Client software can register a tag def handler (block tags, block void - single - tags, inline tags, inline void - single - tags), which will receive the tag def node after parsing and before emission modifications. Thus any tag defs can be authorized, and arbitrary actions can be taken in response to tag def node handling. To change the set of tags allowed by the markup, first get a copy of the emitter. Then get and change the set of allowed tags, and save them back to the emitter: $wiki = new SimpleWiki(); $emitter = $wiki->emitter(); // get copies of the allowed extended tag sets: $blocktags = $emitter->blocktags(); // block tags $vblocktags = $emitter->vblocktags(); // void block tags $itags = $emitter->itags(); // inline tags $vtags = $emitter->vtags(); // void inline tags ... // change the arrays of allowed tags // reset the tag sets $emitter->blocktags($blocktags); // block tags $emitter->vblocktags($vblocktags); // void block tags $emitter->itags($itags); // inline tags $emitter->vtags($vtags); // void inline tags Character filters The Simplewiki emitter returns strings filtered with htmlspecialchars(...) for literal text, by default. Client software can process these strings with alternate or custom character filteres as desired. For example, to support utf-8 entities for your authors (like ✓ (decimal) or ✓ (hex) = checkmark), do the following: Configure your instance of simplewiki like this: $simplewiki->register_charfilter_handler(array($this,'process_htmlentities')); Then define the charfilter handler thus: public function process_htmlentities($text,$node) // not using $node parameters { return htmlentities(html_entity_decode($text,ENT_COMPAT | ENT_HTML401,'UTF-8'), ENT_COMPAT | ENT_HTML401,'UTF-8');// allow html entities } Footnotes: ^[1] See for example w3schools css reference. For color names see the w3schools color reference ^[2] See for example w3 schools about attributes and w3 schools html reference Markup Examples view source markup posted November 21, 2009 In this section we'll try to provide an example of all the markup options, including the native extensions. Basic Markup Basic markup consists of basic inline markup and basic block markup. Inline markup is applied to a phrase or sentence. Block markup is applied to blocks of content. Basic inline markup includes emphasis, strong, linebreak and the escape character. Basic block markup includes paragraphs, headings, horizontal rule (a horizontal line) and related block dividers. Basic in-line markup Emphasis Emphasis (italics) is accomplished with two forward slashed before and after the word or words to be emphasised. So //emphasized// looks like this: emphasized. Note that the forward slashes lean the same way that italics does. Technical note: The parser skips double forward slashes immediately after a colon (:) to avoid italicizing after inline internet protocols (like http://). If you want emphasis markup after a colon, include a space after the colon, and before the double slashes. Strong Strong (bold) is accomplished with two asterisks before and after the word or words to be emphasized. So **strong** looks like this: strong. Both Emphasis and Strong You can combine emphasis and strong: //**emphasis and strong**// looks like this: emphasis and strong. The markup has to be properly nested though, like Chinese dolls. **//does the same thing//** does the same thing (note the inverse order). Line break To break a line into two, place two consecutive backslashes \ where you want the line break to be. The backslashes do not have to be followed by an actual new line in the source text. I put two backslashes before the words "line break" above. Escape character The tilde is the escape character. You can put this in front of a character that would otherwise be interpreted as markup. Here are two backslashes -- \\ -- with the first one preceded by a tilde like this: ~\ (preventing the two backslashes from being interpreted as a line break). Basic block markup Paragraphs Paragraphs are identified simply by a blank row above and below some text. Headings Headings are identified with equals signs (=) beginning a line. The equals signs can be placed at both the beginning and end of a heading for clarity in the markup, but it is only the equals signs at the left that are used to make a determination of the type of heading. Count the equals signs for the heading level, from 1 to 6. for example: ===== Headings ===== Headings can also be decorated by class and style decorators in any combination in this general format: |:h classname* stylerule:stylevalue* stylerule:'stylevalue1 stylevalue2'*:| * denotes repetition Below are a number of examples of headings and class decorators that have been defined for this website. The "h" selector indicates that the decoration applies to the adjacent heading. The decorator has to be positioned at the beginning of the line. The heading decorators apply to any level of heading (1 through 6). Example Markup Heading Level 1 = Heading Level 1= Heading Level 2 == Heading Level 2== Heading Level 3 === Heading Level 3=== Heading Level 4 ==== Heading Level 4==== Heading Level 5 ===== Heading Level 5===== Heading Level 6 ====== Heading Level 6====== Heading high |:h section-divider-high toc=no:|===== Heading high ===== Heading mid |:h section-divider-mid toc=no:|===== Heading mid ===== Heading low |:h section-divider-low toc=no:|===== Heading low ===== Heading major |:h section-major toc=no:|===== Heading major ===== Heading divider-major |:h section-divider-major:| ``===== Heading divider-major ===== Heading subtitle |:h subtitle:|===== Heading subtitle ===== As mentioned above, as with other objects in SimpleWiki, css style rules can also be applied directly. Horizontal Rule and Dividers A horizontal rule (line) is written with 4 dashes on a line of its own: ---- which becomes: Also, there are a number of block decorators (technically empty-block decorators) which act as dividers. Description Markup Effect divider |:b divider:| start below current float spacer |:b spacer:| same as divider, but leaves a blank line fence |:b fence:| draws a dashed line dots |:b dots:| draws a dotted line line |:b line:| same as horizontal rule ---- Each of these has to be on a line by itself. But the markups can be combined: Description Markup Effect divider fence |:b divider fence:| divides and draws a dashed line divider dots |:b divider dots:| divides and draws a dotted line divider line |:b divider line:| divides and same as horizontal rule ---- spacer fence |:b spacer fence:| divides and draws a dashed line spacer dots |:b spacer dots:| divides and draws a dotted line spacer line |:b spacer line:| divides and same as horizontal rule ----