org-special-block-extras: The block and link types

(org-defblock box (&optional (title "") &key background-color shadow frame-color title-background-color
                  &allow-other-keys :latex-head ("xcolor" "tcolorbox") :manual "#Boxed-Text"
                  &context backend raw-contents contents)
              "Enclose text in a box, possibly with a TITLE.

By default, the box's BACKGROUND-COLOR is green for HTML and red for LaTeX;
for LaTeX, there are also FRAME-COLOR and TITLE-BACKGROUND-COLOR.

SHADOW is an alternate style of boxing: It shows the contents in a centred
box with a shadow colour being the given non-nil value of SHADOW.
If SHADOW is a hexadecimal colour, it should be a string enclosed in double quotes.
More accurately, the following are all valid uses:

    #+begin_box title :shadow t
    #+begin_box title :shadow inset

    #+begin_box title :shadow \"pink\"
    #+begin_box title :shadow pink

    #+begin_box title :shadow (cyan pink orange yellow)
    #+begin_box title :shadow (cyan \"inset pink\" orange)
    #+begin_box title :shadow (:left cyan :right pink :deep-right orange :deep-left yellow)

Notice that prefixing colours with ‘inset’ causes the colour to be within the box,
rather than spread, with blur, around the box. The use of ‘inset’ swaps left and right.

The HTML export uses a padded div, whereas the LaTeX export
requires the tcolorbox package; Markdown, sans colours, gets a quote opening with TITLE in bold."
              (pcase (if (org-export-markdown-p) 'md backend)
                ('md (org-parse (format "#+begin_quote\n%s%s\n#+end_quote"
                                        (if (org-string-nw-p (format "%s" title)) (format "*%s*\n\n" title) "")
                                        raw-contents)))
                ;; Colours are named first, since tcolorbox options cannot take hex codes such as #CCFFCC.
                ('latex
                 (concat (org--latex-define-color "osbe-box-back" (or background-color "red!5!white"))
                         (org--latex-define-color "osbe-box-frame" (or frame-color "red!75!black"))
                         (org--latex-define-color "osbe-box-title" (or title-background-color "yellow!50!red"))
                         (format (concat "\\begin{tcolorbox}[title={%s},colback=osbe-box-back,colframe=osbe-box-frame,"
                                         "colbacktitle=osbe-box-title,coltitle=red!25!black, fonttitle=\\bfseries,"
                                         "subtitle style={boxrule=0.4pt, colback=yellow!50!red!25!white}]"
                                         "%s\\end{tcolorbox}")
                                 title contents)))
                (_ (format "<div style=\"%s\"> <h3>%s</h3> %s </div>"
                           (s-join ";" (list "padding: 1em"
                                             (format "background-color: %s" (org-subtle-colors (format "%s" (or background-color "green"))))
                                             "border-radius: 15px"
                                             "font-size: 0.9em"
                                             (org--box-shadow shadow)))
                           title contents))))

(org-defblock details (&optional (title "Details") &key (background-color "#e5f5e5") (title-color "green")
                      &allow-other-keys :latex-head ("xcolor" "tcolorbox") :manual "#Folded-Details"
                      &context backend contents)
              "Enclose contents in a folded up box, for HTML.

For LaTeX, this is just a boring, but centered, box.

By default, the TITLE of such blocks is “Details”,
its TITLE-COLOR is green, and BACKGROUND-COLOR is “#e5f5e5”.

In HTML, we show folded, details, regions with a nice greenish colour."
              (pcase backend
                ('latex (concat (org--latex-define-color "osbe-bg" background-color)
                                (org--latex-define-color "osbe-fg" title-color)
                                (format (concat "\\begin{quote}\n"
                                                "\\begin{tcolorbox}[colback=osbe-bg,colframe=osbe-fg,title={%s},sharp corners,boxrule=0.4pt]\n"
                                                "%s\n"
                                                "\\end{tcolorbox}\n"
                                                "\\end{quote}")
                                        title contents)))
                (_ (format (concat "<details class=\"code-details\" style=\"padding: 1em; background-color: %s; "
                                   "border-radius: 15px; color: hsl(157 75%% 20%%); font-size: 0.9em; "
                                   "box-shadow: 0.05em 0.1em 5px 0.01em #00000057;\">\n"
                                   "<summary><strong><font face=\"Courier\" size=\"3\" color=\"%s\">%s</font></strong></summary>\n"
                                   "%s\n"
                                   "</details>")
                           background-color title-color title contents))))

(org-deflink doc (label &optional description backend)
  "Export LABEL as itself, or as the provided DESCRIPTION,
 along with a tooltip that shows the user's
 documentation-glossary for LABEL and using that entry's name
 when no DESCRIPTION is provided."
  :let (entry (org-docs-get label)
        name (cl-first entry)
        docs (cl-second entry)
        display-name (or description name))
  :help-echo (format "[%s] %s :: %s" label name docs)
  :face '(custom-button)
  :manual "#Glossaries"
  :export (progn
            (add-to-list 'org--docs-actually-used (list label name docs))
            (pcase backend
              ('html (org--html-tooltip docs display-name (org--docs-plain-p label)))
              ;; Make the current word refer to its glossary entry, and declare the location
              ;; that the glossary should refer back to; see `org--docs-glossary'.
              ('latex (format "\\hyperref[o-glossary-%s]{%s}\\label{o-glossary-declaration-site-%s}"
                              label display-name label))
              (_ display-name))))

(org-defblock documentation
              (&optional (name (error "Documentation block: Name must be provided")) &key label show (color "green")
               &allow-other-keys
               ;; A heading tagged :documentation: is an entry in its own right; see `org--docs-read-buffer'.
               :tag nil :manual "#Glossaries" &context raw-contents)
              "A glossary entry: CONTENTS defines NAME, cited as doc:LABEL; a heading tagged :documentation: is one too.

The entries live in ‘org--docs’.

A documentation entry may have its LABEL, its primary identifier,
be:
1. Omitted
2. Given as a single symbol
3. Given as a many aliases '(lbl₀ lbl₁ … lblₙ)

The third case is for when there is no canonical label to refer to
an entry, or it is convenient to use multiple labels for the same
entry.

In all of the above cases, two additional labels are included:
The entry name with spaces replaced by underscores, and again but
all lower case.

Documentation blocks are not shown upon export;
unless SHOW is non-nil, in which case they are shown
using the ‘box’ block, with the provided COLOR passed to it.

Alternatively, a heading tagged :documentation: is an entry, which
exports as an ordinary section: its title is the NAME, its :DOC_KEYS:
property holds the labels, and its own text is the entry.

  * Category Theory                                  :documentation:
    :PROPERTIES:
    :DOC_KEYS: cat cats
    :END:
    A theory of typed composition; e.g., typed monoids.

Entries are read afresh before each export, so they may be cited before
they are defined; see `org--docs-prepare'."
              (dolist (entry (org--docs-entries name label (substring-no-properties raw-contents)))
                (add-to-list 'org--docs entry))
              ;; Should the special block show something upon export?
              (if show (org--blockcall box name :background-color color raw-contents) ""))

(org-defblock parallel (&optional (cols "2") &key bar &allow-other-keys :latex-head ("multicol") :manual "#Parallel"
                       &context backend contents)
              "Place ideas side-by-side, possibly with a separator.

There are COLS many columns, and they may be separated by solid
vertical rules if BAR is a non-nil (colour) value.

+ COLS is either a number or a sequence of the shape: 10% 20% 30%.
+ BAR is either `t', `nil', or a colour such as `red' or `blue'.

----------------------------------------------------------------------

“Soft Columns”: Writing “#+begin_parallel 𝓃 :bar t” will produce
𝒏-many parallel columns, possibly separated by solid rules, or a
“bar”. This style allows text to freely move between columns,
depending on the size of the browser, which may dynamically
shrink and grow.  BAR can either be `t', `nil', or
any (backend)-valid colour specification; such as `red' or
`green'.

“Hard Columns”: Alternatively, for non-uniform column widths,
COLS may instead be a specification of the widths of the
columns. However, this extra flexibility comes at an additional
cost: The contents of the block must now contain 𝒏-1 lines
consisting of ‘#+columnbreak:’, when the specification determines
𝒏 columns, as shown in the following example.

   #+begin_parallel 20% 60% 20% :bar green
   Hello, to the left!

   #+columnbreak:
   A super duper wide middle margin!

   #+columnbreak:
   Goodbye (“God-be-with-ye”) to the right!
   #+end_parallel

The specification is 𝒏 measurements denoting widths; which may be
in any HTML recognisable units; e.g., “5em 20px 30%” is valid.
I personally advise only the use of percentage measurements.

In the Soft Columns style above, any ‘#+columnbreak:’ are merely ignored.
With LaTeX export, the use of ‘#+columnbreak:’ is used to request a column break."
              (let* ((widths (split-string cols))
                     ;; Hard columns have their widths given; e.g., 20% 60% 20%, or 5em 20px.
                     (hard? (--any? (not (string-match-p "\\`[0-9]+\\'" it)) widths))
                     (colour (if (equal (format "%s" bar) "t") "black" bar))
                     ;; A line of its own, so that mentions such as ~#+columnbreak:~ are left alone.
                     (column-break "^[ \t]*#\\+columnbreak:[ \t]*$"))
                (pcase backend
                  ('latex (format (concat "\\par \\setlength{\\columnseprule}{%s pt}\n"
                                          "\\begin{minipage}[t]{\\linewidth}\n"
                                          "\\begin{multicols}{%s}\n%s\n"
                                          "\\end{multicols}\\end{minipage}")
                                  (if bar 2 0)
                                  (if hard? (length widths) cols)
                                  (replace-regexp-in-string column-break "\\\\columnbreak" contents)))
                  ((guard (not hard?))
                   (format "<div style=\"column-count: %s;%s\">%s</div>"
                           cols (if bar (format " column-rule: 1px solid %s;" colour) "") contents))
                  ;; Each width begins a column, separated by a bar unless it is the last; CONTENTS is Org
                  ;; between export fences, so the columns after the first begin within @@html:…@@.
                  (_ (let ((columns (cl-loop for (width . more) on widths
                                             collect (format "<div style=\"width: %s; margin: 10px; border-right: %s;\">"
                                                             width (if (and bar more) (format "4px solid %s" colour) "none"))))
                           (chunks (split-string contents column-break)))
                       (format "<div style=\"display: flex; justify-content: space-between; align-items: flex-start;\">%s</div>"
                               (concat (car columns)
                                       (car chunks)
                                       (cl-loop for column in (cdr columns)
                                                for chunk in (cdr chunks)
                                                concat (format "@@html:</div>%s@@%s" column chunk))
                                       "</div>")))))))

(org-defblock math (&key numbered (matrix "pmatrix") (hints 'between) environment
                         :link nil :latex-head ("amsmath" "xcolor" "cancel") :html-head (mathjax)
                         :edit-indirect-mode latex-mode :manual "#math"
                         :fontify [:language "latex" :keywords org--math-fontify-keywords]
                         &context backend raw-contents anchor)
  "Display maths, wherein our links ---e.g., red:x, [[doc:fold][f]]--- and Org's *markup* are LaTeX's.

  #+begin_math
  # The bounds, declared once; this line is a comment.
  \\def\\xstart{red:a}
  teal:\\bigoplus_{violet:x[fn::the current element] = \\xstart}^{cyan:b} brown:f(violet:x)   teal:<<Fold>>
  #+end_math

Then [[Fold]] cites the equation, as (Fold) in teal; [[Fold][these words]] link to it.

+ red:ATOM colours an ATOM: a {group}; \\left(…\\right); a \\command{with}{arguments}, or a sizer with its
  delimiter, \\big(; a word; else one character.  [[red:][a + b]] colours a + b.  So too for any colour,
  [[color:#ff0066][…]], highlight:, web links, and tooltip: and doc:, which hover in HTML; see `org-math-links'.
+ ATOM[fn::TIP], or ATOM[[tooltip:TIP]], is a tooltip, as [[tooltip:ATOM][TIP]] is, and as in prose: in HTML, TIP hovers over ATOM, by
  tooltips.js; in LaTeX, TIP is a margin note, its number on ATOM.  ATOM[fn:NAME]'s TIP is its “[fn:NAME] TIP”
  definition, elsewhere in the buffer; so one long tip may serve many atoms.
+ A section link, [[*Heading][f]], [[#custom-id][f]], or [[id:ID][f]], links f to that section, as a graph's node does.
+ *bold* /italic/ _underline_ +cancel+ =texttt= ~mathtt~, when the markers hug their text, as in Org's prose.
+ An Org table is a MATRIX, pmatrix by default; as in Org, a line that begins | is a table, so write \\lvert x \\rvert.
+ A description list, “- VALUE :: CONDITION” lines, is a cases environment; a CONDITION of mere words, such as
  otherwise, is prose.
+ A line ending “COLOUR:<<NAME>>”, Org's own target, is tagged NAME, in COLOUR, which [[NAME]] cites, as Org cites
  a target, and C-c C-o on it visits; sans COLOUR, “<<NAME>>” is plain.  NAME may hold maths, as \\meet, ⊑, or a
  subscript, as <<Base Case_1>>.  A hint's \\[ … \\] may be tagged too: “\\[ 0 + n = n teal:<<Base Case>> \\]”.
  NUMBERED numbers the rest.  A block's “#+name: NAME” labels its last line, so [[NAME]] cites it too; it is
  tagged NAME when unnumbered.
+ Lines with an & are aligned at it, as in LaTeX's align; else, lines that end in \\\\ are gathered, each centred on
  a line of its own.  Only the block's own & and \\\\ count, not those in a {group} or a \\begin{cases}…\\end{cases}.
+ “X ={ HINT } Y” states why the step holds, as in a calculational proof; so too for any relation, ≤{ … }, \\equiv{ … },
  … The { hugs the relation, and a space or newline follows it, so x ={a} is no hint; in Emacs, a hint shows as a
  comment does, so we see which {…} is one.  A step runs from its hint to the next, wherever the newlines fall, sans
  our writing \\\\.  A hint may span lines, and shows on those lines, a blank one a gap; within it, \\[ … \\] is a nested
  calculation.  TAB on a hint folds it, as a click does in HTML; M-q within it fills it alone, as prose, whereas M-q
  elsewhere in the block leaves the maths be.
+ HINTS sets each hint between the expressions it relates, maroon, after a bracket that opens it, lest it be mistaken
  for maths; beside, at its step's end, plain, as its column sets it apart; none, hidden from the export; or as a list,
  LAYOUT then FORMAT, LaTeX whose %s is the hint, or folded, or both ---e.g., (beside \"{\\color{teal} %s}\" folded).
  Folded hints start as [⋯] in HTML, so a reader clicks to see each, as a puzzle; LaTeX, sans clicks, shows them.
  To set hints beside throughout a file: #+property: header-args:math :hints beside.
+ ENVIRONMENT overrules the environment the lines imply, for a layout we infer not: e.g., multline* for one long
  equation, or alignat*{2} for columns of a set width.  Sans star, it is numbered; its #+name: labels it.
+ NUMBERED is t, to number each line; or once, to number the lines as one equation, split at their &s; its one tag,
  else its #+name:, labels it.
+ Inline maths, $red:x$ or \\(red:x\\), reads our links and Org's markup too.
+ Unicode, such as ∀ x ∈ ℕ, typesets in HTML, but in LaTeX only with #+latex_compiler: lualatex and
  #+latex_header: \\usepackage{unicode-math}; else, its symbols are dropped, silently.
+ A line “# …” is a comment.  A line that begins \\def, \\let, \\newcommand, \\renewcommand, or \\DeclareMathOperator
  begins a definition, through the line that closes its braces: declared, but not shown.  In LaTeX, it goes to the
  preamble; in HTML, MathJax reads it hidden, and then knows it page-wide.
+ In Markdown, the block is a fenced math block, its definitions within, since GitHub forgets them between blocks.
+ In Emacs, C-c C-c shows the maths as an image atop the block, until C-c C-c again, or an edit; C-c ' edits the
  block in `latex-mode', its hints, tags, and colours shown as in the Org buffer.  C-c C-x C-l, which shows Org's own maths as images, shows math blocks too."
  (pcase-let ((`(,layout ,format ,folded) (org--math-hints-switch hints)))
    (let ((org--math-tips nil) (org--math-hint-format format) (org--math-hint-folded folded))
      (pcase-let ((`(,definitions . ,shown)
                   (org--math-render raw-contents backend numbered matrix anchor layout environment)))
        (cond ((org-export-markdown-p)
               ;; A fenced math block is displayed already, so \[…\] would be one display too many.
               (let ((shown (and shown (string-remove-suffix "\n\\]" (string-remove-prefix "\\[\n" shown)))))
                 (format "```math\n%s\n```" (string-join (append definitions (and shown (list shown))) "\n"))))
              ((equal backend 'latex)
               (concat (when definitions
                         (org-parse (mapconcat (lambda (d) (replace-regexp-in-string "^" "#+latex_header: " d))
                                               definitions "\n")))
                       shown
                       ;; The margin notes of the maths' tooltips, after it, as maths holds no \marginpar.
                       (string-join (reverse org--math-tips))))
              ;; MathJax reads the page's text, wherein a < would begin an HTML tag.
              (t (when org--math-tips (org-html-head-require 'org--tooltip-html-head))
                 ;; Hints fold on a click, by their tip and script; see `org--math-hint-styled'.
                 (when (and shown (string-match-p "osbe-hint" shown))
                   (org-html-head-require 'org--tooltip-html-head)
                   (org-html-head-require 'org--math-hint-html-head))
                 (concat (when definitions
                           (format "<p style=\"display:none\">\\[%s\\]</p>\n"
                                   (org-html-encode-plain-text (string-join definitions "\n"))))
                         (and shown (org-html-encode-plain-text shown))
                         ;; The tips of the maths' tooltips, beside it, since MathJax keeps no <template>.
                         (mapconcat (lambda (tip) (concat "\n" tip)) (reverse org--math-tips) ""))))))))

(org-defblock graph (&optional title &key file svg &allow-other-keys :edit-indirect-mode org-graph-edit-mode
                    :manual "#Graphs" &context backend raw-contents args anchor)
  "Render an Org list + tables as a Graphviz dot graph.

TITLE is the graph's label.
The header's other keys are graph attributes, such as :rankdir LR; :node.KEY and :edge.KEY set node and edge defaults;
:directed nil makes an undirected graph; :wrap N fills labels to N characters a line; :unflatten N staggers
wide rows of leaves over N ranks; and :unknown-tags random-templates gives an unknown tag a made-up template,
rather than erring.  Pass :file foo.png on the
#+begin_graph line to fix the output filename; else a #+name: foo line above the block makes it foo.png, and the graph
a figure that [[foo]] reaches and #+caption: captions; otherwise the name is graph-HASH.png, HASH being that of the
dot source, so re-exporting an unchanged graph rewrites one file rather than adding another.

For HTML export: embeds an inline <svg> element, whose nodes' and arcs' tooltips hover as prose's do, by tooltips.js;
under :svg nil, an inline base64 PNG, sans tooltips.  Either fits the page's width, a click toggling its full size.
For Markdown, it writes the image file and links it, as for a named graph.
For other backends it emits a #+begin_src dot block.  In HTML, a node's [[*Section]] link leads to that section.

With :smartdiagram TYPE ---constellation, flow:horizontal, descriptive, and so on--- LaTeX's smartdiagram package
typesets the list instead, as `org--smartdiagram' says: the #+graph: rows are \\smartdiagramset's, and prose after the
list sits beneath the diagram.  It renders by pdflatex, at :dpi dots per inch, 300 by default; LaTeX export typesets it
in place, adding smartdiagram to the preamble.

Within the block body:

  #+graph: table  ↦ global graph[ ] attributes
  #+node:  table  ↦ default node[ ] attributes
  #+edge:  table  ↦ default edge[ ] attributes
  #+rank:  n1 n2  ↦ { rank=same; n1; n2 } for nodes without a common parent; ids may be [[links]]
  Under an item, #+graph:, #+node:, #+edge:, and #+rank: reach its whole subtree, as Org's inherited properties do.
  #+begin_cluster TITLE :KEY V … #+end_cluster  ↦ subgraph cluster_TITLE { … }; nests, and may sit in an item
  :NAME: … :END:  ↦ a drawer of any name, folding such directives away
  - :T: :: MEANING  ↦ at the top, a legend entry: a sample of template T, captioned MEANING

A #+name: table outside any graph is a template every graph in the buffer may use; the graph's own wins.
A section tagged :graph: exports as a graph of its text, its :PROPERTIES: drawer serving as the header line.

Each list item declares a node.  Nesting encodes edges (parent → child); ordered children, 1. 2. 3., share a rank
in the order written.  An item's text may hold a <<target>>, its id; [[TARGET]] or [[TARGET][LABEL]] links, extra arcs;
and *bold*, /italic/, _underline_, +strike+, =code=, or ~pre~, a braced x^{2} or H_{2}O, or a @@dot:…@@ snippet,
which make its label an HTML-like one; an entity, \\alpha, is its character.  A <<<radio target>>> is a node, every
item mentioning it having an arc to it.  Other Org syntax in a block, such as a headline or #+begin_quote, is an error.
A description tag, `+ L :: CHILD', labels the arc into CHILD; trailing `:T:' tags splice #+name: templates;
an inline footnote, [fn::NOTE], is the node's tooltip, as is a note: a paragraph past the item's first, or a
#+begin_note block ---with `#+begin_note :edge', the arc's---, shown beneath the label instead under :notes inline;
a web, file, or [[*Section]] link, its URL; an [[file:IMAGE.png]], its image;
a checkbox, [X], [-], or [ ], applies the template checked, partial, or unchecked, when one exists; and a `\\\\'
breaks the label's line ---in a table value or #+record: cell, too.
Org's {{{macros}}} expand, by the buffer's #+macro: lines.
A two-column inline table on a list item supplies node attributes.

  | key        | val    |  ↦ a Graphviz attribute of the node; values are quoted for you.
  | :id        | alias  |  ↦ cross-reference name for this node.
  | :edge.KEY  | val    |  ↦ attribute of the arc from the parent; a parallel arc is a second child item.
  | :edge[T].KEY | val  |  ↦ attribute of this item's arc to T, from a [[T]] link; \"rec::port\" reaches a record's port.
  | :inherit   | T₁ T₂  |  ↦ inherit the #+name: templates' rows; explicit rows win.  Also :edge.:inherit, and :T₁:T₂: tags:
                            after an item, its node's; after a reference, or a description term, its arc's.
  A child item that is a lone [[T]] link is a reference to T: an arc to it, styled by the child's :edge.KEY rows.
  | :children-rank | same | ↦ constrain immediate children to the same rank;
                            also accepts min, max, source, sink.
  | shape | cluster |      ↦ make this node an inline subgraph cluster_ID { … }.
  #+record: table       ↦ the node's <TABLE> label, as laid out: a cell's <<p>> is port p, its [[T]] an arc from there;
                            ^ or an empty cell spans, a <l>/<c>/<r> row aligns, and hlines rule.

Example:

  #+begin_graph :rankdir LR
  + A
    + calls :: B
      + returns :: C
  #+end_graph"
  (let* ((smart   (plist-get args :smartdiagram))
         (raw     (org--graph-expand-macros raw-contents))
         ;; HTML inlines a graph's <svg>, for its tooltips, unless told :svg nil; `svg' alone cannot tell nil from omitted.
         (inline-svg (and (eq backend 'html) (not anchor) (not (org-export-markdown-p))
                          (or svg (not (or smart (plist-member args :svg))))))
         (org--graph-tips (and inline-svg (make-hash-table :test #'equal)))
         (dot     (if smart (org--smartdiagram raw title args)
                    (org--graph-raw->dot raw title args)))
         (render  (if smart
                      (lambda (kind file) (org-graph--render-latex dot kind file (org-graph--dpi args)))
                    (lambda (kind file) (org-graph--render dot kind file))))
         ;; The header reads :file foo.png as the symbol foo.png; we want its name.
         (outfile (or (and file (format "%s" file)) (org-graph--named-file anchor svg)
                      (format "graph-%s.png" (substring (md5 dot) 0 12)))))
    (pcase backend
      ;; LaTeX typesets a smartdiagram itself: no image, and its packages join the preamble.
      ((guard (and smart (org-export-derived-backend-p backend 'latex)))
       (dolist (package org-graph-smartdiagram-latex-head) (cl-pushnew package org--latex-head-used :test #'equal))
       (format "\\begin{center}\n%s\n\\end{center}" dot))
      ;; A named graph is a figure: an image link, which the block's #+name: and #+caption: label, as with Babel's results.
      ;; Markdown gets one too, since its renderers strip the inline base64 <img> that HTML gets.
      ((guard (or anchor (org-export-markdown-p)))
       (funcall render (if (s-ends-with-p ".svg" outfile) "svg" "png") outfile)
       (org-parse (format "[[file:%s]]" outfile)))
      (`html
       (let ((tmp (make-temp-file "org-graph-" nil (if inline-svg ".svg" ".png"))))
         (unwind-protect
             ;; An inline <svg> keeps the tooltips; else, an inline base64 PNG.
             (or (when (funcall render (if inline-svg "svg" "png") tmp)
                   (-some-> (if inline-svg (-some--> (org-graph--svg-contents tmp) (org-graph--svg-tooltips it org--graph-tips))
                              (format "<img src=\"data:image/png;base64,%s\" alt=\"graph\" />" (org-graph--png-to-base64 tmp)))
                     org-graph--fit-width))
                 ;; dot unavailable, or its output sans <svg>: emit the raw dot source in a <pre>, its tooltips as text.
                 (format "<pre>%s</pre>" (s-replace "<" "&lt;" (if (and inline-svg (not smart))
                                                                    (let (org--graph-tips)
                                                                      (org--graph-raw->dot raw title args))
                                                                  dot))))
           (delete-file tmp))))
      (_
       ;; `org-parse' lets Org export the src block, rather than emit its raw syntax into the output.
       (org-parse (if smart (format "#+begin_src latex\n%s\n#+end_src" dot)
                    (format "#+begin_src dot :file %s\n%s\n#+end_src" outfile dot)))))))

(org-defblock highlight
              (&optional (color "yellow") &allow-other-keys :latex-head ("xcolor") :manual "#Highlights"
               :link [:face (list :background (or (org-string-nw-p label) "yellow"))]
               &context backend raw-contents contents link?)
              "Highlight text with a background of COLOR, which is yellow by default; as a link, it is so highlighted in Emacs too.

  [[highlight:pink][Read this twice.]]

For LaTeX, a hex COLOR such as #e5f5e5 needs no quotes; a block's text is a full-width paragraph box.
In Markdown, the text is <mark>ed, paragraph by paragraph, which GitHub shows yellow whatever COLOR is."
              (pcase (if (org-export-markdown-p) 'md backend)
                ('md (if link?
                         (format "<mark>%s</mark>" contents)
                       (org-parse (format "@@html:<mark>@@%s@@html:</mark>@@"
                                          (s-replace-regexp "\n\n+" "@@html:</mark>@@\n\n@@html:<mark>@@" (s-trim raw-contents))))))
                ('latex (concat (org--latex-define-color "osbe-highlight" color)
                                (if link?
                                    (format "\\colorbox{osbe-highlight}{%s}" contents)
                                  (format "\\colorbox{osbe-highlight}{\\parbox{\\dimexpr\\linewidth-2\\fboxsep}{%s}}" contents))))
                ;; A block's text is paragraphs, which a <span> may not hold.
                (_ (format (if link?
                               "<span style=\"background-color:%s;\">%s</span>"
                             "<div style=\"background-color:%s;\">%s</div>")
                           color contents))))