cortav  Diff

Differences From Artifact [5df14cacc3]:

To Artifact [0c4afc6088]:


     6      6   the cortav [!format] can be called [!cortavgil], or [!gil cortavi], to differentiate it from the reference implementation [!cortavsir] or [!sir cortavi].
     7      7   
     8      8   %toc
     9      9   
    10     10   ## cortav vs. markdown
    11     11   the most important difference between cortav and markdown is that cortav is strictly line-oriented. this choice was made to ensure that cortav was relatively easy to parse. so while a simple [`.ct] file may look a bit like a [`.md] file, in reality it's a lot closer to gemtext than any flavor of markdown.
    12     12   
           13  +however, the differences go much deeper. the most distinctive feature of cortav is that its syntax is strongly recursive. with markdown, you can apply at most one styling to any given block or span or text. with cortav, you can nest as many styles as you like, and you can style text in places markdown wouldn't ordinarily let you: within headings, inside link text, even in code listings if you absolutely insist (this needs to be turned on by a special directive before the listing in question, however).
           14  +
           15  +this manual describes cortav exhaustively, but if you just want a quick reference on how markdown translates to cortav, look no further.
           16  +
           17  +* [*headings]: cortav uses almost the same syntax for headings that markdown does, except it only allows the "ATX style" headings, with one or more hash characters at the start of the line. the only differences from markdown are:
           18  +** you can use the unicode section character [`§] instead of [`#] if you're feeling snobby
           19  +** you must put a space between the control sequence (the sequence of hashes or section symbols, in this case) and the title text. [`# title] creates a section with the heading text "title", but [`#title] creates a new section with no heading at all; instead, it gives the anonymous section the ID [`title]. and of course, you can combine the two: [`#ttl title] creates a section with the heading text "title" and the ID [`ttl]. what are IDs for? we'll get to that in a little bit
           20  +* [*paragraphs] are mostly the same as in markdown, except that a paragraph break occurs after every newline character, not every blank line. paragraphs can be indented by however many spaces you like; such indentation will be ignored. (tabs have a special meaning, however). in cortav, you can also explicitly mark a line of text as a paragraph by preceding it with a period character ([`.]), which is useful if you want to start a paragraph with text that would otherwise be interpreted specially.
           21  +* [*italic text] -- or rather, [!emphasized] text -- is written as [`\[!my spiffy italic text\]]. in cortav, these spans can be nested within other spans (or titles, or table cells, or…), and the starting and ending point is unambiguous.
           22  +* [*bold text] -- or rather, [*strong] text -- is written as [`\[*my commanding bold text\]].
           23  +* [*bold-italic text] -- or rather, [![*emphasized strong text]] -- has no specific notation. rather, you create it by nesting one span within the other, for instance: [`\[*[!my ostentatious bold-italic text\]]].
           24  +* [*links] are quite different from their markdown equivalents. cortav does not have inline links, as it is intended to be easily readable in both formatted and plain-text format, and long URLs rather disrupt the flow of reading. rather, a link tag is written with the notation [`\[>nifty-link my nifty link\]], where the word [`nifty-link] immediately following the arrow is an [!identifier] indicating the destination of the link. (instead of a greater-than sign, you can also use the unicode arrow symbol [`→].) if the identifier is the same as one you've assigned to a section, cortav produces a link within the document to that section. otherwise, it will look for a [!reference] to tell it the URI for the link. a reference is a key-value pair created by adding a line like [`nifty-link: https://zombo.com] [!indented by exactly one tab]. you can place this reference anywhere you like so long as it's in the same section; if you want to name a reference in another section, you have to prefix it with that section's ID, e.g. [`\[>spiffy-section.nifty-link my nifty link declared in a spiffy section\]].
           25  +* [*lists] use a different syntax from markdown. you can start a line with a [`*] to create an unordered list, or [`:] to create an ordered list; indentation doesn't matter. if you want to nest list items, instead of putting two spaces before the child item, you just add another star or colon. and of course, you can nest lists of different kinds within one another.
           26  +* [*horizontal rules] use roughly the same syntax: three or more hyphens on a line of their own ([`\---]). underlines also work ([`___], [`-_-], [`__-__-__] etc).
           27  +* some markdown implementations support [*tables]. cortav does too, using a very simple notation.
           28  +* [*underlines] are supported by some markdown implementations. in cortav, you can apply them with the notation [`\[_my underlined text\]] -- please just use them sparingly when you render to HTML!
           29  +* [*strikethrough] is supported by some extended versions of markdown. cortav uses the notation [`\[~my deleted text\]], with the intended semantics of text that is being removed by some revision of a document. (you can also denote text that is being [!added] by using a plus sign instead of a tilde)
           30  +* [*images] are a bit more complicated. see the section on [>rsrc resources] for an explanation.
           31  +* [*smart quotes] and [*em dashes] are inserted automatically, just as in markdown, provided you have the [>tsmog transmogrify] extension available. (it is part of the reference implementation and defined by the spec, but not required.) in fact, you can insert longer dashes than em dashes just by increasing the number of hyphens. the reference implementation's transmogrifier also translates ascii arrows like [`\-->] into their unicode equivalents ([`→]).
           32  +* [*literals] (also known as [*code text]) can be inserted with the [`\[`int main(void);] syntax. note however that literals are not protected from the transmogrifier, and are parsed like any other span, which may cause problems if the source code you're quoting makes use of such forbidden runes. in this case, you'll want to wrap the code span in a raw span. the syntax for this is [`\[`[\\int main(void);\]]], but since this is a bit unwieldy it can also be abbreviated as [`\[`\\int main(void);\]].
           33  +
           34  +of course, this is only a small taste of what cortav can do, not even touching on key features like macros, footnotes, or equation formatting. read the sections on [>onblocks blocks] and [>onspans spans] for all the gory details.
           35  +
    13     36   ## encoding
    14     37   a cortav document is made up of a sequence of codepoints. UTF-8 must be supported, but other encodings (such as UTF-32 or C6B) may be supported as well. lines will be derived by splitting the codepoints at the linefeed character or equivalent. note that unearthly encodings like C6B or EBCDIC will need to select their own control sequences.
    15     38   
    16     39   ## file type
    17     40   a cortav source file is identified using a file extension, file type, and/or magic byte sequence.
    18     41   
    19     42   three file extensions are defined as identifying a cortav source file. where relevant, all must be recognized as indicating a cortav source file.
................................................................................
    39     62   it is also possible to indicate the nature of a cortav file without using filesystem metadata. this is done by prefixing the file with a magic byte sequence. the sequence used depends on the encoding.
    40     63   * for UTF-8 and ASCII plain text files, [`%ct[!\\n]] (that is, the byte sequence [`0x25 63 74 0A]) should be used
    41     64   * for C6B+PS files (parastream), the file should begin with the paragraph [`], which equates to the byte sequence [` 0x3E 2E 14 0C 01 04 00 00 00 03 07 3E 2D], including the parastream header).
    42     65   consequently, this sequence should be ignored by a cortav parser at the start of a file (except as an indication of file format).
    43     66   
    44     67   for FreeDesktop-based systems, the [`build/velartrill-cortav.xml] file included in the repository supplies mappings for the extensions and magic byte sequences. a script is also included which can be registered with xdg-open so that double-clicking on a cortav file will render it out and open it in your default web browser. [`$ make install] will generate the necessary FreeDesktop XML files and register them, as well as install the script and the [`cortav] executable itself. for more information see [>refimpl-build building the reference implementation].
    45     68   
    46         -## structure
           69  +##onblocks structure
    47     70   cortav is based on an HTML-like block model, where a document consists of sections, which are made up of blocks, which may contain a sequence of spans. flows of text are automatically conjoined into spans, and blocks are separated by one or more newlines. this means that, unlike in markdown, a single logical paragraph [*cannot] span multiple ASCII lines. the primary purpose of this was to ensure ease of parsing, but also, both markdown and cortav are supposed to be readable from within a plain text editor. this is the 21st century. every reasonable text editor supports soft word wrap, and if yours doesn't, that's entirely your own damn fault.
    48     71   
    49     72   the first character(s) of every line (the "control sequence") indicates the role of that line. if no control sequence is recognized, the line is treated as a paragraph. the currently supported control sequences are listed below. some control sequences have alternate forms, in order to support modern, readable unicode characters as well as plain ascii text.
    50     73   
    51     74   * [*paragraphs] ([`.] [` ¶] [`❡]): a paragraph is a simple block of text. the period control sequence is only necessary if the paragraph text starts with text that would be interpreted as a control sequence otherwise
    52     75   * newlines [` \\]: inserts a line break into previous paragraph and attaches the following text. mostly useful for poetry or lyrics
    53     76   * [*section starts] [`#] [`§]: starts a new section. all sections have an associated depth, determined by the number of sequence repetitions (e.g. "###" indicates depth-three"). sections may have headers and IDs; both are optional. IDs, if present, are a sequence of raw-text immediately following the hash marks. if the line has one or more space character followed by styled-text, a header will be attached. the character immediately following the hashes can specify a particular type of section. e.g.:
    54     77   ** [`#] is a simple section break.
    55     78   ** [`#anchor] opens a new section with the ID [`anchor].
    56     79   ** [`# header] opens a new section with the title "header".
    57     80   ** [`#anchor header] opens a new section with both the ID [`anchor] and the title "header".
    58     81   ** [`#>conversation] opens a blockquote section named [`conversation] without a header.
    59         -* [*nonprinting sections] ([`^]): sometimes, you'll want to create a namespace without actually adding a visible new section to the document. you can achieve this by creating a [!nonprinting section] and defining resources within it. nonprinting sections can also be used to store comments, notes, or other information that is useful to have in the source file without it becoming a part of the output
    60     82   ** [`#&id mime] opens a new inline object [`id] of type [`mime]. useful for embedding SVGs. the ID and mime type must be specified.
           83  +* [*nonprinting sections] ([`^]): sometimes, you'll want to create a namespace without actually adding a visible new section to the document. you can achieve this by creating a [!nonprinting section] and defining resources within it. nonprinting sections can also be used to store comments, notes, or other information that is useful to have in the source file without it becoming a part of the output
    61     84   * [*resource] ([`@]): defines a [!resource]. a resource is an file or object that exists outside of the document but which will be included in the document somehow. common examples of resources include images, videos, iframes, or headers/footers. see [>rsrc resources] for more information.
    62     85   * [*lists] ([`*] [`:]): these are like paragraph nodes, but list nodes that occur next to each other will be arranged so as to show they compose a sequence. depth is determined by the number of stars/colons. like headers, a list entry may have an ID that can be used to refer back to it; it is indicated in the same way. if colons are used, this indicates that the order of the items is signifiant. :-lists and *-lists may be intermixed; however, note than only the last character in the sequence actually controls the depth type.
    63     86   * [*directives] ([`%]): a directive issues a hint to the renderer in the form of an arbitrary string. directives are normally ignored if they are not supported, but you may cause a warning to be emitted where the directive is not supported with [`%!] or mark a directive critical with [`%!!] so that rendering will entirely fail if it cannot be parsed.
    64     87   * [*comments] ([`%%]): a comment is a line of text that is simply ignored by the renderer.
    65     88   * [*asides] ([`!]): indicates text that diverges from the narrative, and can be skipped without interrupting it. think of it like block-level parentheses. asides which follow one another are merged as paragraphs of the same aside, usually represented as a sort of box. if the first line of an aside contains a colon, the stretch of styled-text from the beginning to the aside to the colon will be treated as a "type heading," e.g. "Warning:"
    66     89   * [*code] ([`~~~]): a line beginning with ~~~ begins or terminates a block of code. code blocks are by default not parsed, but parsing can be activated by preceding the code block with an [`%[*expand]] directive. the opening line should look like one of the below
    67     90   ** [`~~~]
................................................................................
    77    100   * [*blockquote] ([`>]): alternate blockquote syntax. can be nested by repeating the [`>] character.
    78    101   * [*subtitle] ([`--]): attaches a subtitle to the previous header
    79    102   * [*embed] ([`&]): embeds a referenced object. can be used to show images or repeat previously defined objects like lists or tables, optionally with a caption.
    80    103   ** [`&$[$macro] [$arg1]|[$arg2]|[$argn]…] invokes a block-level macro with the supplied arguments
    81    104   *** [`&$mymacro arg 1|arg 2|arg 3]
    82    105   ** [`&[$image]] embeds an image or other block-level object. [!image] can be a reference with a url or file path, or it can be an embed section (e.g. for SVG files)
    83    106   ***[`&myimg All that remained of the unfortunate blood magic pageant contestants and audience (police photo)]
    84         -** [`&-[$section]] embeds a closed disclosure element. in interactive outputs, this will display as a block [!section] which can be clicked on to view the full contents of the referenced section; in static outputs, it will display as an enclosed box with [$section] as the title text
          107  +** [`&-[$section] [$styled-text]] embeds a closed disclosure element. in interactive outputs, this will display as a block [!section] which can be clicked on to view the full contents of the referenced section; if [$styled-text] is present, it overrides the title of the section you are embedding. in static outputs, the disclosure object will display as an enclosed box with [$styled-text] as the title text
    85    108   *** [`&-ex-a Prosecution Exhibit A (GRAPHIC CONTENT)]
    86         -** [`&+[$section]] is like the above, but the disclosure element is open by default
          109  +** [`&+[$section] [$styled-text]] is like the above, but the disclosure element is open by default
    87    110   * [*horizontal rule] ([`\---]): inserts a horizontal rule or other context break; does not end the section. must be followed by newline. underlines can also be used in place of dashes.
    88    111   * [*page break] ([`\^^]): for formats that support pagination, like HTML (when printed), indicates that the rest of the current page should be blank. for formats that do not, extra margins will be inserted. does not create a new section
    89         -* [*page rule] ([`\^^-]): inserts a page break for formats that support them, and a horizontal rule for formats that do not. does not create a new section
          112  +* [*page rule] ([`\^-^]): inserts a page break for formats that support them, and a horizontal rule for formats that do not. does not create a new section
    90    113   * [*table cells] ([`+ |]): see [>ex.tab table examples].
    91    114   * [*equations] ([`=]) block-level equations can be inserted with the [`=]
    92    115   * [*empty lines] (that is, lines consisting of nothing but whitespace) constitute a [!break], which terminates multiline objects that do not have a dedicated termination sequence, for example lists and asides.
    93    116   
    94         -## styled text
          117  +##onspans styled text
    95    118   most blocks contain a sequence of spans. these spans are produced by interpreting a stream of [*styled-text] following the control sequence. styled-text is a sequence of codepoints potentially interspersed with escapes. an escape is formed by an open square bracket [`\[] followed by a [*span control sequence], and arguments for that sequence like more styled-text. escapes can be nested.
    96    119   
    97    120   * strong {obj *|styled-text}: causes its text to stand out from the narrative, generally rendered as bold or a brighter color.
    98    121   * emphatic {obj !|styled-text}: indicates that its text should be spoken with emphasis, generally rendered as italics
    99    122   * literal {obj `|styled-text}: indicates that its text is a reference to a literal sequence of characters or other discrete token. generally rendered in monospace
   100    123   * variable {obj $|styled-text}: indicates that its text is a stand-in that will be replaced with what it names. generally rendered in italic monospace, ideally of a different color
   101    124   * underline {obj _|styled-text}: underlines the text. use sparingly on text intended for webpages -- underlined text  [!is] distinct from links, but underlining non-links is still a violation of convention.
   102    125   * strikeout {obj ~|styled-text}: indicates that its text should be struck through or otherwise indicated for deletion
   103    126   * insertion {obj +|styled-text}: indicates that its text should be indicated as a new addition to the text body.
   104    127   ** consider using a macro definition [`\edit: [~[#1]][+[#2]]] to save typing if you are doing editing work
   105    128   * link \[>[!ref] [!styled-text]\]: produces a hyperlink or cross-reference denoted by [$ref], which may be either a URL specified with a reference or the name of an object like an image or section elsewhere in the document. the unicode characters [`→] and [`🔗] can also be used instead of [`>] to denote a link.
   106    129   * footnote {span ^|ref|[$styled-text]}: annotates the text with a defined footnote. in interactive output media [`\[^citations.qtheo Quantum Theosophy: A Neophyte's Catechism]] will insert a link with the next [`Quantum Theosophy: A Neophyte's Catechism] that, when clicked, causes a footnote to pop up on the screen. for static output media, the text will simply have a superscript integer after it denoting where the footnote is to be found.
   107         -* superscript {obj '|[$styled-text]}:
   108         -* subscript {obj ,|[$styled-text]}:
          130  +* superscript {obj '|[$styled-text]}
          131  +* subscript {obj ,|[$styled-text]}
   109    132   * raw \[\\[`raw-text]\]: causes all characters within to be interpreted literally, without expansion. the only special characters are square brackets, which must have a matching closing bracket
   110    133   * raw literal \[$\\[!raw-text]\]: shorthand for [\[$[\…]]]
   111    134   * macro [`\{[!name] [!arguments]\}]: invokes a [>ex.mac macro], specified with a reference
   112    135   * argument {obj #|var}: in macros only, inserts the [$var]-th argument. otherwise, inserts a context variable provided by the renderer.
   113    136   * raw argument {obj ##|var}: like above, but does not evaluate [$var].
   114    137   * term {obj &|name}, {span &|name|[$expansion]}: quotes a defined term with a link to its definition, optionally with a custom expansion of the term (for instance, to expand the first use of an acronym)
   115    138   * inline image {obj &@|name}: shows a small image or other object inline. the unicode character [`🖼] can also be used instead of [`&@].
................................................................................
   119    142   * critical extension {span %!|ext|…}: like [!extension], but will trigger an error if the requested extension is not available
   120    143   * extension text {span %:|ext|styled-text}: like [!extension], but when the requested extension is not present, [$styled-text] wlil be emitted as-is. this is a better way to apply CSS classes, as the text will still be visible when rendered to formats other than HTML.
   121    144   * inline comment {obj %%|...}: ignored. useful for editorial annotations not intended to be part of the rendered product.
   122    145   
   123    146   	span: [` \[[*[#1]][$[#2]] [#3]\]]
   124    147   	obj: [` \[[*[#1]][$[#2]]\]]
   125    148   
          149  +##tabs tables
          150  +tables are encoded using a very simple notation. any line that begins with a plus [`+] or bar [`|] denotes a table row. each plus or bar separates one column from the other: a plus opens a new header cell, a bar opens a new normal cell.
          151  +
          152  +the alignment of a cell can be specified by placing colons at one edge or both edges of the given cell. a colon on the left ([`|: my table cell |]) indicates a left-aligned cell, a colon on right a right-aligned cell ([`| my table cell :|]), and a colon on both sides a centered cell ([`|: my table cell :|]). if you want to use a special character without it being eaten by the table parser, just put a backslash in from of it, e.g. [`| this cell \| contains a pipe \+ a plus sign [!and] ends with a colon \:|]. and of course, table cells are just normal spans -- they can contain any other kind of span formatting you like, such as links, emphasis, or footnotes.
          153  +
          154  +no other features (like colspans or rowspans) are currently part of the spec but they will be added eventually (if i can figure out a decent way to implement them without creating a huge mess).
          155  +
          156  +you can finish each row with a bar or plus character, but it's not necessary. only do it if you think it makes the source easier to read.
          157  +
          158  +* [>ex.tab an example of table notation]
          159  +
   126    160   ##ident identifiers
   127    161   any identifier (including a reference) that is defined within a named section must be referred to from outside that section as [`[!sec].[!obj]], where [$sec] is the ID of the containing section and [$obj] is the ID of the object one wishes to reference.
   128    162   
   129    163   ##rsrc resources
   130    164   a [!resource] represents content that is not encoded directly into the source file, but which is embedded by some means in the output. resources can either be [!embedded], in which case they are compiled into the final document itself, or they can be [!linked], in which case the final document only contains a URI or similar tag referencing the resource. not all render backends support both linking and embedding embedding, nor do all backends support all object types (for instance, [`groff] does not support video embedding.)
   131    165   
   132    166   a resource definition is begun by line consisting of an [`@] sign and an [>ident identifier]. this line is followed by any number of parameters. a parameter is a line beginning with a single tab, a keyword, a colon, and a then a value. additional lines can be added to a parameter by following it with a line that consists of two tabs followed by the text you wish to add. (this is the same syntax used by references.) a resource definition is terminated by a break, or any line that does not begin with a tab
................................................................................
   321    355   * {d include} transcludes another file
   322    356   * {d import} reads in the contents of another file as an embeddable section
   323    357   * {d quote} transcludes another file, without expanding the text except for paragraphs 
   324    358   * {d embed}, where possible, embeds another file as an object within the current one. in HTML this could be accomplished with e.g. an iframe.
   325    359   * {d expand} causes the next object (usually a code block) to be fully expanded when it would otherwise not be
   326    360   * {d font} controls the font stack, for outputs that support changing fonts. see [>fonts fonts] for more information.
   327    361   * {d lang} changes the current language, which is used by extensions to e.g. control typographical conventions, and may be encoded into the output by certain renderers (e.g. HTML). note that quotes and blockquotes can be set to a separate language with a simpler syntax. the language should be notated using IETF language tags
   328         -** {d lang is x-ranuir-CR8} sets the current language to Ranuir as spoken in the Central Worlds, written in Corran and encoded using UTF-8. this might be used at the top of a document to set its primary language.
          362  +** {d lang is x-ranuir-Cent-CR8} sets the current language to Ranuir as spoken in the Central Worlds, written in Corran and encoded using UTF-8. this might be used at the top of a document to set its primary language.
   329    363   ** {d lang push gsw-u-sd-chzh} temporarily switches to Zürich German, e.g. to quote a German passage in an otherwise Ranuir document
   330    364   ** {d lang sec en-US} switches to American English for the duration of a section. does not affect the language stack.
   331    365   ** {d lang pop} drops the current language off the language stack, returning to whatever was pushed or set before it. this would be used, for instance, at the end of a passage
   332    366   * {d pragma} supplies semantic data about author intent, the kind of information the document contains and hints about how it should be displayed to the user. think of them like offhand remarks to the renderer -- there's no guarantee that it'll pay any attention, but if it does, your document will look better. pragmas have no scope; they affect the entire document. the pragma function exists primarily as a means to allow parameters that would normally need to be specified on e.g. the command line to be encoded in the document instead in a way that multiple implementations can understand. a few standard pragmas are defined.
   333    367   ** {d pragma layout} gives a hint on how the document should be layed out. the first hint that is understood will be applied; all others will be discarded. standard hints include:
   334    368   *** [`essay]
   335    369   *** [`narrative]
................................................................................
   453    487   * [`%lua use [!file]]: evaluates [$file] and makes its definitions available
   454    488   * [`\[%lua raw [!script]\]]: evaluates [$script] and emits the string it returns (if any) in raw span context.
   455    489   * [` \[%lua exp [!script]\]]: evaluates [$script] and emits the string it returns (if any) in expanded span context.
   456    490   * [`%lua raw [!script]]: evaluates [$script] and emits the string array it returns (if any) in raw block context.
   457    491   * [`%lua exp [!script]]: evaluates [$script] and emits the string array it returns (if any) in expanded block context.
   458    492   
   459    493   the interpreter should provide a [`cortav] table with the objects:
   460         -* ctx: contains context variables
          494  +* [`ctx]: contains context variables
   461    495   
   462    496   used files should return a table with the following members
   463         -* macros: an array of functions that return strings or arrays of strings when invoked. these will be injected into the global macro namespace.
          497  +* [`macros]: an array of functions that return strings or arrays of strings when invoked. these will be injected into the global macro namespace.
   464    498   
   465    499   ###ts ts
   466    500   the [*ts] extension allows documents to be marked up for basic classification constraints and automatically redacted. if you are seriously relying on ts for confidentiality, make damn sure you start the file with [$%[*requires] ts], so that rendering will fail with an error if the extension isn't supported.
   467    501   
   468    502   ts enables the directives:
   469    503   * [`%[*ts] class [$scope level] ([$styled-text])]: indicates a classification level for either the while document (scope [$doc]) or the next section (scope [$sec]). if the ts level is below [$level], the section will be redacted or rendering will fail with an error, as appropriate. if styled-text is included, this will be treated as the name of the classification level.
   470    504   * [`%[*ts] word [$scope word] ([$styled-text])]: indicates a codeword clearance that must be present for the text to render. if styled-text is present, this will be used to render the name of the codeword instead of [$word].
................................................................................
   571    605   the command line driver is built and installed with a GNU [$make] script. this script accepts the variables shown below with their default values:
   572    606   + prefix | [`[$$HOME]/.local] | the path under which the package will be installed
   573    607   + build | [`build] |  the directory where generated objects will be placed; useful for out-of-tree builds
   574    608   + bin-prefix | [`[$$prefix]/bin] | directory to install the executables to"
   575    609   + default-format-flags | [`-m html:width 35em] | a list of flags that will be passed by the viewer script to [`cortav] when generating a html fille
   576    610   
   577    611   the following targets are supplied to automate the build:
   578         -* [`install] builds everything, installs the executable and the viewer script to [$$bin_prefix], and registers the viewer script with XDG
          612  +* [`install] builds everything, installs the bytecode-executable and the viewer script to [$$bin_prefix], and registers the viewer script with XDG
          613  +* [`install-bin] is like [`install] but installs the binary version instead of the bytecode one
   579    614   * [`excise] deletes everything installed and deregisters the file handlers (note that the same variables must be passed to [`exicse] as were passed to [`install]!)
   580    615   * [`clean] deletes build artifacts from the [$$build] directory like it was never there
   581    616   * [`wipe] is equivalent to [`$ make excise && make clean]
          617  +
          618  +if you don't want to install [`cortav], you can just run [`$ make] without arguments to build the executable.
          619  +
          620  +there are two different ways of building the driver. one is to generate a bytecode file that can be executed directly as a script. this is the most straightforward method, and requires only [`lua] and [`luac]. however, it has several substantial downsides: because it's only a bytecode file, it requires the [`lua] interpreter to run -- and in some environments, the security characteristics of the [`lua] interpreter may make this undesirable. it also must hardcode the path to the lua interpreter (though admittedly this is easy enough to fix if you copy it to another machine of the same architecture). [`lua] is not an entirely predictable environment, as it is controlled by environment variables and may hypothetically do things like load default libraries or alter paths in ways that disrupt the workings of [`cortav]. finally, because the bytecode file is not a binary executable, it cannot directly be given enhanced capabilities on unix-like systems through filesystem metadata -- SUID and caps will be ignored by the kernel. while this is of no importance in ordinary operation, there are niche cases where this could be troublesome.
          621  +
          622  +a potentially superior alternative is to build [`cortav] as a directly executable binary. when you tell [`make] to build the binary version, it first compiles the driver to raw bytecode, then invokes [`tool/makeshim.lua] to create a C source file embedding that bytecode, which is then piped into a C compiler. the huge downside, of course, is that building the cortav driver in this way requires a C compiler. however, the binary that it produces is easier to distribute to other computers -- you can even statically link in lua so it can run on systems where lua isn't installed.
          623  +
          624  +to build the binary version, run [`$ make build/cortav.bin]. if you want to make the build to link lua statically, you'll additionally need to supply lua's library prefix in the variable [`lua-lib-prefix]. some example  incantations:
          625  +* [`$ make build/cortav.bin lua-lib-prefix=/usr/lib] on most Linux distros
          626  +* [`$ make build/cortav.bin lua-lib-prefix=/usr/local/lib] on FreeBSD
          627  +* [`$ make build/cortav.bin lua-lib-prefix=$(nix path-info nixpkgs.lua5_3)/lib] on NixOS, or on OSX if you're using the Nix package manager
          628  +
          629  +alternately, you can build lua yourself and link the static library in place without installing it systemwide, which is useful if you want to build a specialized version of lua to link with (or if the sysop doesn't want your grubby luser hands all over his precious filesystem). note that if you're building a self-contained version of [`cortav] to distribute, you may want to slim down the binary by building lua without its parser, as the self-contained version of the driver only needs the bytecode VM part of lua to run.
          630  +
          631  +#### build variables
          632  +there are numerous variables you can use to control the build process.
          633  +
          634  ++ lua | path to the lua interpreter [`cortav] should be built and run with
          635  ++ luac | path to the lua compiler
          636  ++ sh | path to a bourne-compatible shell
          637  ++ extens | list of paths to extensions to enable, defaults to [`ext/*.lua]. use [`extens\+=[$path]] to add additional extensions from out of tree
          638  ++ rendrs | list of paths to renderers to enable, defaults to [`render/*.lua]
          639  ++ build | path to the build directory, defaults to [`build]. change this for out-of-tree builds
          640  ++ executable | name of the executable to be generated, defaults to [`cortav]
          641  ++ default-format-flags | specifies command line options that the viewer script should pass to [`cortav]
          642  ++ prefix | where files should be installed, defaults to [`$HOME/.local]
          643  ++ bin-prefix | where executables should be installed, defaults to [`$(prefix)/bin]
          644  ++ debug | if set, builds executables with debugging symbols; if absent, executables are stripped
          645  ++ encoding-data | if set, embeds character class data for supported multibyte encodings into the program. on by default; [`$ make encoding-data=] to unset
          646  ++ encoding-data-ucs | path to the UnicodeData.txt file for UCS-based encodings like UTF-8. by default it is automatically downloaded with [`curl]
          647  ++ encoding-data-ucs-url | where to download UnicodeData.txt from, if encoding-data-ucs is not changed. defaults to the unicode consortium website
          648  +
          649  +#### deterministic builds
          650  +some operating systems, like NixOS, require packages that can be built in reproducible ways. this implies that all data, all [!state] that goes into producing a package needs to be accounted for before the build proper begins. the [`cortav] build process needs to be slightly altered to support such a build process.
          651  +
          652  +while the cortav specification itself does not concern itself with matters like whether a particular character is a numeral or a letter, optimal typesetting in some cases requires such information. this is the case for the equation span- and block-types, which need to be able to distinguish between literals, variables, and mathematical symbols in [^alas-math the equations they format]. the ASCII charset is small enough that exhaustive character class information can be manually hardcoded into a cortav implementation, the various encodings of Unicode most certainly are not.
          653  +
          654  +	alas-math: sadly, i was not at any point consulted by any of the generations of mathematicians stretching back into antiquity who devised their notations without any regard for machine-readability. [!for shame!]
          655  +
          656  +for this reason, the reference implementation of cortav embeds the file [`UnicodeData.txt], a database maintained by the Unicode Consortium. this is a rather large file that updates for each new Unicode version, so it is downloaded as part of the build process. to build on NixOS, you'll need to either disable the features that rely on this database (not recommended), or download the database yourself and tell the build script where to find it. this is the approach the official nix expression will take when i can be bothered to write it. see the examples below for how to conduct a deterministic build
          657  +
          658  +~~~ deterministic build with unicode database [sh] ~~~
          659  +/src $ mkdir cortav && cd cortav
          660  +/src/cortav $ fossil clone https://c.hale.su/cortav .fossil && fossil open .fossil
          661  +/src/cortav $ curl https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt > /tmp/unicode.txt
          662  +/src/cortav $ make build/cortav encoding-data-ucs=/tmp/unicode.txt
          663  +~~~
          664  +~~~ [sh] deterministic build [!without] unicode database ~~~
          665  +/src $ mkdir cortav && cd cortav
          666  +/src/cortav $ fossil clone https://c.hale.su/cortav .fossil && fossil open .fossil
          667  +/src/cortav $ make build/cortav encoding-data=
          668  +~~~
          669  +
          670  +! while most of the data used is taken directly from UnicodeData.txt, the database generated by [`tools/ucs.lua] splices in some extra character information before generating a database. this is partly because certain characters may not be classified in a useful way and need to be manually overwritten. however, the reference implementation also seeks to provide accurate data for certain character sets that are not part of unicode proper and can be expressed in UTF only through its private use areas.
          671  +! currently, only the [>corran Corran] script is currently supported in this fashion, but i intend to add [>tengwar Tengwar] as well. if there is a con-script or any other informally encoded script you would like supported by the reference implementation, please open an issue.
          672  +
          673  +[*do note] that no cortav implementation needs to concern itself with character class data. this functionality is provided in the reference implementation strictly as an (optional) extension to the spec to improve usability, not as a normative requirement.
          674  +
          675  +	corran: http://ʞ.cc/fic/spirals/society
          676  +	tengwar: https://en.wikipedia.org/wiki/Tengwar
   582    677   
   583    678   ###refimpl-switches switches
   584    679   [`cortav.lua] offers various switches to control its behavior.
   585    680   + long                      + short + function                                    +
   586    681   | [`--out [!file]]              :|:[`-o]:| sets the output file (default stdout)       |
   587    682   | [`--log [!file]]              :|:[`-l]:| sets the log file (default stderr)          |
   588    683   | [`--define [!var] [!val]]     :|:[`-d]:| sets the context variable [$var] to [$val]  |
................................................................................
   638    733   [`html] supplies the following render directives.
   639    734   
   640    735   * [`%[*html] link [$rel] [$mime] [$href]]: inserts a [`<link>] tag in the header, for example, to link in an alternate stylesheet, or help feed readers find your atom or rss feed.
   641    736   ** [`%[*html] link alternate\\ stylesheet text/css /res/style2.css]
   642    737   ** [`%[*html] link alternate application/atom+xml /feed.atom]
   643    738   * [`%[*html] style [$id]]: adds the stylesheet referenced by [$id] into the document stylesheet. the stylesheet is specified using a [>rsrc resource].
   644    739   
   645         -#### stylsheets
          740  +#### stylesheets
   646    741   the [`html] backend offers some additional directives for external CSS files that are embedded into the document, in order to simplify integration with the accent mechanism. these are:
   647    742   
   648    743   * [`@[*fg]]: resolves to a color expression denoting the selected foreground color. equivalent to [`[*tone](1)]
   649    744   * [`@[*bg]]: resolves to a color expression denoting the selected background color. equivalent to [`[*tone](0)]
   650    745   * [`@[*tone]\[/[$alpha]\]([$fac] \[[$shift] \[[$saturate]\]\] )]: resolves to a color expression. [$fac] is a floating-point value scaling from the background color to the foreground color. [$shift] is a value in degrees controlling how far the hue will shift relative to the accent. [$saturate] is a floating-point value controlling how satured the color is.
   651    746   
   652    747   ###refimpl-rend-groff groff
................................................................................
   657    752   ####refimpl-rend-groff-modes modes
   658    753   [`groff] supports the following modes:
   659    754   
   660    755   * string [`groff:annotate] controls how footnotes will be handled.
   661    756   ** [`footnote] places footnotes at the end of the page they are referenced on. if the same footnote is used on multiple pages, it will be duplicated on each.
   662    757   ** [`secnote] places footnotes at the end of each section. footnotes used in multiple sections will be duplicated for each
   663    758   ** [`endnote] places all footnotes at the end of the rendered document.
   664         -* string [`groff:dev] names an output device (such as [`dvi] or[`pdf]). if this mode is present, [`groff] will be automatically invoked
          759  +* string [`groff:dev] names an output device (such as [`dvi] or [`pdf]). if this mode is present, [`groff] will be automatically invoked
   665    760   * string [`groff:title-page] takes an identifier that names a section. this section will be treated as the title page for the document.
   666    761   
   667    762   ### directives
   668    763   * [`%[*pragma] title-page [$id]] sets the title page to section [$id]. this causes it to be specially formatted, with a large, centered title and subtitle.
   669    764   
   670    765   ### quirks
   671    766   if the [`toc] extension is active but [`%[*toc]] directive is provided, the table of contents will be given its own section at the start of the document (after the title page, if any).
................................................................................
   732    827   				(note . "footnote1-text")
   733    828   				(ref . "papal-disclaimer")
   734    829   				(nodes
   735    830   					"footnode1-caption-text"))
   736    831   			(text (id . "text4") "has thus far had little to say on the matter, provoking rampant speculation among the faithful.")
   737    832   			(footnote-def (id . "footnote1-def")
   738    833   				(nodes "footnote1-text")
   739         -			(text (id . "footnote1-text") "Currently recognized as legitimate successor to Peter of Terra by 2,756 sects, rejected by 678 of mostly Neo-Lutheran origin, and decried as an antipope by 73, most notably Pope Peter II of Centaurus Secundus, leader of the ongoing relativistic crusade against star systems owned by Microsoft.")
          834  +			(text (id . "footnote1-text") "Currently recognized as legitimate successor to Peter of Terra by 2,756 sects, rejected by 678 of mostly Neo-Lutheran origin, and decried as an antipope by 73, most notably Pope Peter II of Centaurum Secundus, leader of the ongoing relativistic crusade against star systems owned by Microsoft.")
   740    835   			;;; snip ;;;
   741    836   			(document
   742    837   				(nodes
   743    838   					"section1" "section2")))
   744    839   		~~~
   745    840   
   746    841   some formats may eventually warrant their own renderer, but are not a priority: