lisp/ox-md.el

   1 ;;; ox-md.el --- Markdown Back-End for Org Export Engine -*- lexical-binding: t; -*-
   2
   3 ;; Copyright (C) 2012-2017 Free Software Foundation, Inc.
   4
   5 ;; Author: Nicolas Goaziou <n.goaziou@gmail.com>
   6 ;; Keywords: org, wp, markdown
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software: you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation, either version 3 of the License, or
  13 ;; (at your option) any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 ;;; Commentary:
  24
  25 ;; This library implements a Markdown back-end (vanilla flavor) for
  26 ;; Org exporter, based on `html' back-end.  See Org manual for more
  27 ;; information.
  28
  29 ;;; Code:
  30
  31 (require 'cl-lib)
  32 (require 'ox-html)
  33 (require 'ox-publish)
  34
  35 \f
  36 ;;; User-Configurable Variables
  37
  38 (defgroup org-export-md nil
  39   "Options specific to Markdown export back-end."
  40   :tag "Org Markdown"
  41   :group 'org-export
  42   :version "24.4"
  43   :package-version '(Org . "8.0"))
  44
  45 (defcustom org-md-headline-style 'atx
  46   "Style used to format headlines.
  47 This variable can be set to either `atx' or `setext'."
  48   :group 'org-export-md
  49   :type '(choice
  50           (const :tag "Use \"atx\" style" atx)
  51           (const :tag "Use \"Setext\" style" setext)))
  52
  53
  54 ;;;; Footnotes
  55
  56 (defcustom org-md-footnotes-section "%s%s"
  57   "Format string for the footnotes section.
  58 The first %s placeholder will be replaced with the localized Footnotes section
  59 heading, the second with the contents of the Footnotes section."
  60  :group 'org-export-md
  61  :type 'string
  62  :version "26.1"
  63  :package-version '(Org . "9.0"))
  64
  65 (defcustom org-md-footnote-format "<sup>%s</sup>"
  66   "Format string for the footnote reference.
  67 The %s will be replaced by the footnote reference itself."
  68   :group 'org-export-md
  69   :type 'string
  70   :version "26.1"
  71   :package-version '(Org . "9.0"))
  72
  73 \f
  74 ;;; Define Back-End
  75
  76 (org-export-define-derived-backend 'md 'html
  77   :filters-alist '((:filter-parse-tree . org-md-separate-elements))
  78   :menu-entry
  79   '(?m "Export to Markdown"
  80        ((?M "To temporary buffer"
  81             (lambda (a s v b) (org-md-export-as-markdown a s v)))
  82         (?m "To file" (lambda (a s v b) (org-md-export-to-markdown a s v)))
  83         (?o "To file and open"
  84             (lambda (a s v b)
  85               (if a (org-md-export-to-markdown t s v)
  86                 (org-open-file (org-md-export-to-markdown nil s v)))))))
  87   :translate-alist '((bold . org-md-bold)
  88                      (code . org-md-verbatim)
  89                      (example-block . org-md-example-block)
  90                      (export-block . org-md-export-block)
  91                      (fixed-width . org-md-example-block)
  92                      (headline . org-md-headline)
  93                      (horizontal-rule . org-md-horizontal-rule)
  94                      (inline-src-block . org-md-verbatim)
  95                      (inner-template . org-md-inner-template)
  96                      (italic . org-md-italic)
  97                      (item . org-md-item)
  98                      (keyword . org-md-keyword)
  99                      (line-break . org-md-line-break)
 100                      (link . org-md-link)
 101                      (node-property . org-md-node-property)
 102                      (paragraph . org-md-paragraph)
 103                      (plain-list . org-md-plain-list)
 104                      (plain-text . org-md-plain-text)
 105                      (property-drawer . org-md-property-drawer)
 106                      (quote-block . org-md-quote-block)
 107                      (section . org-md-section)
 108                      (src-block . org-md-example-block)
 109                      (template . org-md-template)
 110                      (verbatim . org-md-verbatim))
 111   :options-alist
 112   '((:md-footnote-format nil nil org-md-footnote-format)
 113     (:md-footnotes-section nil nil org-md-footnotes-section)
 114     (:md-headline-style nil nil org-md-headline-style)))
 115
 116 \f
 117 ;;; Filters
 118
 119 (defun org-md-separate-elements (tree _backend info)
 120   "Fix blank lines between elements.
 121
 122 TREE is the parse tree being exported.  BACKEND is the export
 123 back-end used.  INFO is a plist used as a communication channel.
 124
 125 Enforce a blank line between elements.  There are two exceptions
 126 to this rule:
 127
 128   1. Preserve blank lines between sibling items in a plain list,
 129
 130   2. In an item, remove any blank line before the very first
 131      paragraph and the next sub-list when the latter ends the
 132      current item.
 133
 134 Assume BACKEND is `md'."
 135   (org-element-map tree (remq 'item org-element-all-elements)
 136     (lambda (e)
 137       (org-element-put-property
 138        e :post-blank
 139        (if (and (eq (org-element-type e) 'paragraph)
 140                 (eq (org-element-type (org-element-property :parent e)) 'item)
 141                 (org-export-first-sibling-p e info)
 142                 (let ((next (org-export-get-next-element e info)))
 143                   (and (eq (org-element-type next) 'plain-list)
 144                        (not (org-export-get-next-element next info)))))
 145            0
 146          1))))
 147   ;; Return updated tree.
 148   tree)
 149
 150
 151 \f
 152 ;;; Transcode Functions
 153
 154 ;;;; Bold
 155
 156 (defun org-md-bold (_bold contents _info)
 157   "Transcode BOLD object into Markdown format.
 158 CONTENTS is the text within bold markup.  INFO is a plist used as
 159 a communication channel."
 160   (format "**%s**" contents))
 161
 162
 163 ;;;; Code and Verbatim
 164
 165 (defun org-md-verbatim (verbatim _contents _info)
 166   "Transcode VERBATIM object into Markdown format.
 167 CONTENTS is nil.  INFO is a plist used as a communication
 168 channel."
 169   (let ((value (org-element-property :value verbatim)))
 170     (format (cond ((not (string-match "`" value)) "`%s`")
 171                   ((or (string-prefix-p "`" value)
 172                        (string-suffix-p "`" value))
 173                    "`` %s ``")
 174                   (t "``%s``"))
 175             value)))
 176
 177
 178 ;;;; Example Block, Src Block and export Block
 179
 180 (defun org-md-example-block (example-block _contents info)
 181   "Transcode EXAMPLE-BLOCK element into Markdown format.
 182 CONTENTS is nil.  INFO is a plist used as a communication
 183 channel."
 184   (replace-regexp-in-string
 185    "^" "    "
 186    (org-remove-indentation
 187     (org-export-format-code-default example-block info))))
 188
 189 (defun org-md-export-block (export-block contents info)
 190   "Transcode a EXPORT-BLOCK element from Org to Markdown.
 191 CONTENTS is nil.  INFO is a plist holding contextual information."
 192   (if (member (org-element-property :type export-block) '("MARKDOWN" "MD"))
 193       (org-remove-indentation (org-element-property :value export-block))
 194     ;; Also include HTML export blocks.
 195     (org-export-with-backend 'html export-block contents info)))
 196
 197
 198 ;;;; Headline
 199
 200 (defun org-md-headline (headline contents info)
 201   "Transcode HEADLINE element into Markdown format.
 202 CONTENTS is the headline contents.  INFO is a plist used as
 203 a communication channel."
 204   (unless (org-element-property :footnote-section-p headline)
 205     (let* ((level (org-export-get-relative-level headline info))
 206            (title (org-export-data (org-element-property :title headline) info))
 207            (todo (and (plist-get info :with-todo-keywords)
 208                       (let ((todo (org-element-property :todo-keyword
 209                                                         headline)))
 210                         (and todo (concat (org-export-data todo info) " ")))))
 211            (tags (and (plist-get info :with-tags)
 212                       (let ((tag-list (org-export-get-tags headline info)))
 213                         (and tag-list
 214                              (format "     :%s:"
 215                                      (mapconcat 'identity tag-list ":"))))))
 216            (priority
 217             (and (plist-get info :with-priority)
 218                  (let ((char (org-element-property :priority headline)))
 219                    (and char (format "[#%c] " char)))))
 220            ;; Headline text without tags.
 221            (heading (concat todo priority title))
 222            (style (plist-get info :md-headline-style)))
 223       (cond
 224        ;; Cannot create a headline.  Fall-back to a list.
 225        ((or (org-export-low-level-p headline info)
 226             (not (memq style '(atx setext)))
 227             (and (eq style 'atx) (> level 6))
 228             (and (eq style 'setext) (> level 2)))
 229         (let ((bullet
 230                (if (not (org-export-numbered-headline-p headline info)) "-"
 231                  (concat (number-to-string
 232                           (car (last (org-export-get-headline-number
 233                                       headline info))))
 234                          "."))))
 235           (concat bullet (make-string (- 4 (length bullet)) ?\s) heading tags "\n\n"
 236                   (and contents (replace-regexp-in-string "^" "    " contents)))))
 237        (t
 238         (let ((anchor
 239                (and (org-md--headline-referred-p headline info)
 240                     (format "<a id=\"%s\"></a>"
 241                             (or (org-element-property :CUSTOM_ID headline)
 242                                 (org-export-get-reference headline info))))))
 243           (concat (org-md--headline-title style level title anchor tags)
 244                   contents)))))))
 245
 246
 247 (defun org-md--headline-referred-p (headline info)
 248   "Non-nil when HEADLINE is being referred to.
 249 INFO is a plist used as a communication channel.  Links and table
 250 of contents can refer to headlines."
 251   (unless (org-element-property :footnote-section-p headline)
 252     (or
 253      ;; Global table of contents includes HEADLINE.
 254      (and (plist-get info :with-toc)
 255           (memq headline
 256                 (org-export-collect-headlines info (plist-get info :with-toc))))
 257      ;; A local table of contents includes HEADLINE.
 258      (cl-some
 259       (lambda (h)
 260         (let ((section (car (org-element-contents h))))
 261           (and
 262            (eq 'section (org-element-type section))
 263            (org-element-map section 'keyword
 264              (lambda (keyword)
 265                (when (equal "TOC" (org-element-property :key keyword))
 266                  (let ((case-fold-search t)
 267                        (value (org-element-property :value keyword)))
 268                    (and (string-match-p "\\<headlines\\>" value)
 269                         (let ((n (and
 270                                   (string-match "\\<[0-9]+\\>" value)
 271                                   (string-to-number (match-string 0 value))))
 272                               (local? (string-match-p "\\<local\\>" value)))
 273                           (memq headline
 274                                 (org-export-collect-headlines
 275                                  info n (and local? keyword))))))))
 276              info t))))
 277       (org-element-lineage headline))
 278      ;; A link refers internally to HEADLINE.
 279      (org-element-map (plist-get info :parse-tree) 'link
 280        (lambda (link)
 281          (eq headline
 282              (pcase (org-element-property :type link)
 283                ((or "custom-id" "id") (org-export-resolve-id-link link info))
 284                ("fuzzy" (org-export-resolve-fuzzy-link link info))
 285                (_ nil))))
 286        info t))))
 287
 288 (defun org-md--headline-title (style level title &optional anchor tags)
 289   "Generate a headline title in the preferred Markdown headline style.
 290 STYLE is the preferred style (`atx' or `setext').  LEVEL is the
 291 header level.  TITLE is the headline title.  ANCHOR is the HTML
 292 anchor tag for the section as a string.  TAGS are the tags set on
 293 the section."
 294   (let ((anchor-lines (and anchor (concat anchor "\n\n"))))
 295     ;; Use "Setext" style
 296     (if (and (eq style 'setext) (< level 3))
 297         (let* ((underline-char (if (= level 1) ?= ?-))
 298                (underline (concat (make-string (length title) underline-char)
 299                                   "\n")))
 300           (concat "\n" anchor-lines title tags "\n" underline "\n"))
 301         ;; Use "Atx" style
 302         (let ((level-mark (make-string level ?#)))
 303           (concat "\n" anchor-lines level-mark " " title tags "\n\n")))))
 304
 305 ;;;; Horizontal Rule
 306
 307 (defun org-md-horizontal-rule (_horizontal-rule _contents _info)
 308   "Transcode HORIZONTAL-RULE element into Markdown format.
 309 CONTENTS is the horizontal rule contents.  INFO is a plist used
 310 as a communication channel."
 311   "---")
 312
 313
 314 ;;;; Italic
 315
 316 (defun org-md-italic (_italic contents _info)
 317   "Transcode ITALIC object into Markdown format.
 318 CONTENTS is the text within italic markup.  INFO is a plist used
 319 as a communication channel."
 320   (format "*%s*" contents))
 321
 322
 323 ;;;; Item
 324
 325 (defun org-md-item (item contents info)
 326   "Transcode ITEM element into Markdown format.
 327 CONTENTS is the item contents.  INFO is a plist used as
 328 a communication channel."
 329   (let* ((type (org-element-property :type (org-export-get-parent item)))
 330          (struct (org-element-property :structure item))
 331          (bullet (if (not (eq type 'ordered)) "-"
 332                    (concat (number-to-string
 333                             (car (last (org-list-get-item-number
 334                                         (org-element-property :begin item)
 335                                         struct
 336                                         (org-list-prevs-alist struct)
 337                                         (org-list-parents-alist struct)))))
 338                            "."))))
 339     (concat bullet
 340             (make-string (- 4 (length bullet)) ? )
 341             (pcase (org-element-property :checkbox item)
 342               (`on "[X] ")
 343               (`trans "[-] ")
 344               (`off "[ ] "))
 345             (let ((tag (org-element-property :tag item)))
 346               (and tag (format "**%s:** "(org-export-data tag info))))
 347             (and contents
 348                  (org-trim (replace-regexp-in-string "^" "    " contents))))))
 349
 350
 351
 352 ;;;; Keyword
 353
 354 (defun org-md-keyword (keyword contents info)
 355   "Transcode a KEYWORD element into Markdown format.
 356 CONTENTS is nil.  INFO is a plist used as a communication
 357 channel."
 358   (pcase (org-element-property :key keyword)
 359     ((or "MARKDOWN" "MD") (org-element-property :value keyword))
 360     ("TOC"
 361      (let ((case-fold-search t)
 362            (value (org-element-property :value keyword)))
 363        (cond
 364         ((string-match-p "\\<headlines\\>" value)
 365          (let ((depth (and (string-match "\\<[0-9]+\\>" value)
 366                            (string-to-number (match-string 0 value))))
 367                (local? (string-match-p "\\<local\\>" value)))
 368            (org-remove-indentation
 369             (org-md--build-toc info depth keyword local?)))))))
 370     (_ (org-export-with-backend 'html keyword contents info))))
 371
 372
 373 ;;;; Line Break
 374
 375 (defun org-md-line-break (_line-break _contents _info)
 376   "Transcode LINE-BREAK object into Markdown format.
 377 CONTENTS is nil.  INFO is a plist used as a communication
 378 channel."
 379   "  \n")
 380
 381
 382 ;;;; Link
 383
 384 (defun org-md-link (link contents info)
 385   "Transcode LINE-BREAK object into Markdown format.
 386 CONTENTS is the link's description.  INFO is a plist used as
 387 a communication channel."
 388   (let ((link-org-files-as-md
 389          (lambda (raw-path)
 390            ;; Treat links to `file.org' as links to `file.md'.
 391            (if (string= ".org" (downcase (file-name-extension raw-path ".")))
 392                (concat (file-name-sans-extension raw-path) ".md")
 393              raw-path)))
 394         (type (org-element-property :type link)))
 395     (cond
 396      ;; Link type is handled by a special function.
 397      ((org-export-custom-protocol-maybe link contents 'md))
 398      ((member type '("custom-id" "id" "fuzzy"))
 399       (let ((destination (if (string= type "fuzzy")
 400                              (org-export-resolve-fuzzy-link link info)
 401                            (org-export-resolve-id-link link info))))
 402         (pcase (org-element-type destination)
 403           (`plain-text                  ; External file.
 404            (let ((path (funcall link-org-files-as-md destination)))
 405              (if (not contents) (format "<%s>" path)
 406                (format "[%s](%s)" contents path))))
 407           (`headline
 408            (format
 409             "[%s](#%s)"
 410             ;; Description.
 411             (cond ((org-string-nw-p contents))
 412                   ((org-export-numbered-headline-p destination info)
 413                    (mapconcat #'number-to-string
 414                               (org-export-get-headline-number destination info)
 415                               "."))
 416                   (t (org-export-data (org-element-property :title destination)
 417                                       info)))
 418             ;; Reference.
 419             (or (org-element-property :CUSTOM_ID destination)
 420                 (org-export-get-reference destination info))))
 421           (_
 422            (let ((description
 423                   (or (org-string-nw-p contents)
 424                       (let ((number (org-export-get-ordinal destination info)))
 425                         (cond
 426                          ((not number) nil)
 427                          ((atom number) (number-to-string number))
 428                          (t (mapconcat #'number-to-string number ".")))))))
 429              (when description
 430                (format "[%s](#%s)"
 431                        description
 432                        (org-export-get-reference destination info))))))))
 433      ((org-export-inline-image-p link org-html-inline-image-rules)
 434       (let ((path (let ((raw-path (org-element-property :path link)))
 435                     (if (not (file-name-absolute-p raw-path)) raw-path
 436                       (expand-file-name raw-path))))
 437             (caption (org-export-data
 438                       (org-export-get-caption
 439                        (org-export-get-parent-element link)) info)))
 440         (format "![img](%s)"
 441                 (if (not (org-string-nw-p caption)) path
 442                   (format "%s \"%s\"" path caption)))))
 443      ((string= type "coderef")
 444       (let ((ref (org-element-property :path link)))
 445         (format (org-export-get-coderef-format ref contents)
 446                 (org-export-resolve-coderef ref info))))
 447      ((equal type "radio") contents)
 448      (t (let* ((raw-path (org-element-property :path link))
 449                (path
 450                 (cond
 451                  ((member type '("http" "https" "ftp"))
 452                   (concat type ":" raw-path))
 453                  ((string= type "file")
 454                   (org-export-file-uri (funcall link-org-files-as-md raw-path)))
 455                  (t raw-path))))
 456           (if (not contents) (format "<%s>" path)
 457             (format "[%s](%s)" contents path)))))))
 458
 459
 460 ;;;; Node Property
 461
 462 (defun org-md-node-property (node-property _contents _info)
 463   "Transcode a NODE-PROPERTY element into Markdown syntax.
 464 CONTENTS is nil.  INFO is a plist holding contextual
 465 information."
 466   (format "%s:%s"
 467           (org-element-property :key node-property)
 468           (let ((value (org-element-property :value node-property)))
 469             (if value (concat " " value) ""))))
 470
 471
 472 ;;;; Paragraph
 473
 474 (defun org-md-paragraph (paragraph contents _info)
 475   "Transcode PARAGRAPH element into Markdown format.
 476 CONTENTS is the paragraph contents.  INFO is a plist used as
 477 a communication channel."
 478   (let ((first-object (car (org-element-contents paragraph))))
 479     ;; If paragraph starts with a #, protect it.
 480     (if (and (stringp first-object) (string-prefix-p "#" first-object))
 481         (concat "\\" contents)
 482       contents)))
 483
 484
 485 ;;;; Plain List
 486
 487 (defun org-md-plain-list (_plain-list contents _info)
 488   "Transcode PLAIN-LIST element into Markdown format.
 489 CONTENTS is the plain-list contents.  INFO is a plist used as
 490 a communication channel."
 491   contents)
 492
 493
 494 ;;;; Plain Text
 495
 496 (defun org-md-plain-text (text info)
 497   "Transcode a TEXT string into Markdown format.
 498 TEXT is the string to transcode.  INFO is a plist holding
 499 contextual information."
 500   (when (plist-get info :with-smart-quotes)
 501     (setq text (org-export-activate-smart-quotes text :html info)))
 502   ;; Protect ambiguous #.  This will protect # at the beginning of
 503   ;; a line, but not at the beginning of a paragraph.  See
 504   ;; `org-md-paragraph'.
 505   (setq text (replace-regexp-in-string "\n#" "\n\\\\#" text))
 506   ;; Protect ambiguous !
 507   (setq text (replace-regexp-in-string "\\(!\\)\\[" "\\\\!" text nil nil 1))
 508   ;; Protect `, *, _ and \
 509   (setq text (replace-regexp-in-string "[`*_\\]" "\\\\\\&" text))
 510   ;; Handle special strings, if required.
 511   (when (plist-get info :with-special-strings)
 512     (setq text (org-html-convert-special-strings text)))
 513   ;; Handle break preservation, if required.
 514   (when (plist-get info :preserve-breaks)
 515     (setq text (replace-regexp-in-string "[ \t]*\n" "  \n" text)))
 516   ;; Return value.
 517   text)
 518
 519
 520 ;;;; Property Drawer
 521
 522 (defun org-md-property-drawer (_property-drawer contents _info)
 523   "Transcode a PROPERTY-DRAWER element into Markdown format.
 524 CONTENTS holds the contents of the drawer.  INFO is a plist
 525 holding contextual information."
 526   (and (org-string-nw-p contents)
 527        (replace-regexp-in-string "^" "    " contents)))
 528
 529
 530 ;;;; Quote Block
 531
 532 (defun org-md-quote-block (_quote-block contents _info)
 533   "Transcode QUOTE-BLOCK element into Markdown format.
 534 CONTENTS is the quote-block contents.  INFO is a plist used as
 535 a communication channel."
 536   (replace-regexp-in-string
 537    "^" "> "
 538    (replace-regexp-in-string "\n\\'" "" contents)))
 539
 540
 541 ;;;; Section
 542
 543 (defun org-md-section (_section contents _info)
 544   "Transcode SECTION element into Markdown format.
 545 CONTENTS is the section contents.  INFO is a plist used as
 546 a communication channel."
 547   contents)
 548
 549
 550 ;;;; Template
 551
 552 (defun org-md--build-toc (info &optional n keyword local)
 553   "Return a table of contents.
 554
 555 INFO is a plist used as a communication channel.
 556
 557 Optional argument N, when non-nil, is an integer specifying the
 558 depth of the table.
 559
 560 Optional argument KEYWORD specifies the TOC keyword, if any, from
 561 which the table of contents generation has been initiated.
 562
 563 When optional argument LOCAL is non-nil, build a table of
 564 contents according to the current headline."
 565   (concat
 566    (unless local
 567      (let ((style (plist-get info :md-headline-style))
 568            (title (org-html--translate "Table of Contents" info)))
 569        (org-md--headline-title style 1 title nil)))
 570    (mapconcat
 571     (lambda (headline)
 572       (let* ((indentation
 573               (make-string
 574                (* 4 (1- (org-export-get-relative-level headline info)))
 575                ?\s))
 576              (number (format "%d."
 577                              (org-last
 578                               (org-export-get-headline-number headline info))))
 579              (bullet (concat number (make-string (- 4 (length number)) ?\s)))
 580              (title
 581               (format "[%s](#%s)"
 582                       (org-export-data-with-backend
 583                        (org-export-get-alt-title headline info)
 584                        ;; Create an anonymous back-end that will
 585                        ;; ignore any footnote-reference, link,
 586                        ;; radio-target and target in table of
 587                        ;; contents.
 588                        (org-export-create-backend
 589                         :parent 'md
 590                         :transcoders '((footnote-reference . ignore)
 591                                        (link . (lambda (object c i) c))
 592                                        (radio-target . (lambda (object c i) c))
 593                                        (target . ignore)))
 594                        info)
 595                       (or (org-element-property :CUSTOM_ID headline)
 596                           (org-export-get-reference headline info))))
 597              (tags (and (plist-get info :with-tags)
 598                         (not (eq 'not-in-toc (plist-get info :with-tags)))
 599                         (let ((tags (org-export-get-tags headline info)))
 600                           (and tags
 601                                (format ":%s:"
 602                                        (mapconcat #'identity tags ":")))))))
 603         (concat indentation bullet title tags)))
 604     (org-export-collect-headlines info n (and local keyword)) "\n")
 605    "\n"))
 606
 607 (defun org-md--footnote-formatted (footnote info)
 608   "Formats a single footnote entry FOOTNOTE.
 609 FOOTNOTE is a cons cell of the form (number . definition).
 610 INFO is a plist with contextual information."
 611   (let* ((fn-num (car footnote))
 612          (fn-text (cdr footnote))
 613          (fn-format (plist-get info :md-footnote-format))
 614          (fn-anchor (format "fn.%d" fn-num))
 615          (fn-href (format " href=\"#fnr.%d\"" fn-num))
 616          (fn-link-to-ref (org-html--anchor fn-anchor fn-num fn-href info)))
 617     (concat (format fn-format fn-link-to-ref) " " fn-text "\n")))
 618
 619 (defun org-md--footnote-section (info)
 620   "Format the footnote section.
 621 INFO is a plist used as a communication channel."
 622   (let* ((fn-alist (org-export-collect-footnote-definitions info))
 623          (fn-alist (cl-loop for (n _type raw) in fn-alist collect
 624                             (cons n (org-trim (org-export-data raw info)))))
 625          (headline-style (plist-get info :md-headline-style))
 626          (section-title (org-html--translate "Footnotes" info)))
 627     (when fn-alist
 628       (format (plist-get info :md-footnotes-section)
 629               (org-md--headline-title headline-style 1 section-title)
 630               (mapconcat (lambda (fn) (org-md--footnote-formatted fn info))
 631                          fn-alist
 632                          "\n")))))
 633
 634 (defun org-md-inner-template (contents info)
 635   "Return body of document after converting it to Markdown syntax.
 636 CONTENTS is the transcoded contents string.  INFO is a plist
 637 holding export options."
 638   ;; Make sure CONTENTS is separated from table of contents and
 639   ;; footnotes with at least a blank line.
 640   (concat
 641    ;; Table of contents.
 642    (let ((depth (plist-get info :with-toc)))
 643      (when depth
 644        (concat (org-md--build-toc info (and (wholenump depth) depth)) "\n")))
 645    ;; Document contents.
 646    contents
 647    "\n"
 648    ;; Footnotes section.
 649    (org-md--footnote-section info)))
 650
 651 (defun org-md-template (contents _info)
 652   "Return complete document string after Markdown conversion.
 653 CONTENTS is the transcoded contents string.  INFO is a plist used
 654 as a communication channel."
 655   contents)
 656
 657
 658 \f
 659 ;;; Interactive function
 660
 661 ;;;###autoload
 662 (defun org-md-export-as-markdown (&optional async subtreep visible-only)
 663   "Export current buffer to a Markdown buffer.
 664
 665 If narrowing is active in the current buffer, only export its
 666 narrowed part.
 667
 668 If a region is active, export that region.
 669
 670 A non-nil optional argument ASYNC means the process should happen
 671 asynchronously.  The resulting buffer should be accessible
 672 through the `org-export-stack' interface.
 673
 674 When optional argument SUBTREEP is non-nil, export the sub-tree
 675 at point, extracting information from the headline properties
 676 first.
 677
 678 When optional argument VISIBLE-ONLY is non-nil, don't export
 679 contents of hidden elements.
 680
 681 Export is done in a buffer named \"*Org MD Export*\", which will
 682 be displayed when `org-export-show-temporary-export-buffer' is
 683 non-nil."
 684   (interactive)
 685   (org-export-to-buffer 'md "*Org MD Export*"
 686     async subtreep visible-only nil nil (lambda () (text-mode))))
 687
 688 ;;;###autoload
 689 (defun org-md-convert-region-to-md ()
 690   "Assume the current region has Org syntax, and convert it to Markdown.
 691 This can be used in any buffer.  For example, you can write an
 692 itemized list in Org syntax in a Markdown buffer and use
 693 this command to convert it."
 694   (interactive)
 695   (org-export-replace-region-by 'md))
 696
 697
 698 ;;;###autoload
 699 (defun org-md-export-to-markdown (&optional async subtreep visible-only)
 700   "Export current buffer to a Markdown file.
 701
 702 If narrowing is active in the current buffer, only export its
 703 narrowed part.
 704
 705 If a region is active, export that region.
 706
 707 A non-nil optional argument ASYNC means the process should happen
 708 asynchronously.  The resulting file should be accessible through
 709 the `org-export-stack' interface.
 710
 711 When optional argument SUBTREEP is non-nil, export the sub-tree
 712 at point, extracting information from the headline properties
 713 first.
 714
 715 When optional argument VISIBLE-ONLY is non-nil, don't export
 716 contents of hidden elements.
 717
 718 Return output file's name."
 719   (interactive)
 720   (let ((outfile (org-export-output-file-name ".md" subtreep)))
 721     (org-export-to-file 'md outfile async subtreep visible-only)))
 722
 723 ;;;###autoload
 724 (defun org-md-publish-to-md (plist filename pub-dir)
 725   "Publish an org file to Markdown.
 726
 727 FILENAME is the filename of the Org file to be published.  PLIST
 728 is the property list for the given project.  PUB-DIR is the
 729 publishing directory.
 730
 731 Return output file name."
 732   (org-publish-org-to 'md filename ".md" plist pub-dir))
 733
 734 (provide 'ox-md)
 735
 736 ;; Local variables:
 737 ;; generated-autoload-file: "org-loaddefs.el"
 738 ;; End:
 739
 740 ;;; ox-md.el ends here