lisp/ox-md.el

   1 ;;; ox-md.el --- Markdown Back-End for Org Export Engine -*- lexical-binding: t; -*-
   2
   3 ;; Copyright (C) 2012-2016 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 "25.2"
  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 "25.2"
  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            (anchor
 221             (and (plist-get info :with-toc)
 222                  (format "<a id=\"%s\"></a>"
 223                          (or (org-element-property :CUSTOM_ID headline)
 224                              (org-export-get-reference headline info)))))
 225            ;; Headline text without tags.
 226            (heading (concat todo priority title))
 227            (style (plist-get info :md-headline-style)))
 228       (cond
 229        ;; Cannot create a headline.  Fall-back to a list.
 230        ((or (org-export-low-level-p headline info)
 231             (not (memq style '(atx setext)))
 232             (and (eq style 'atx) (> level 6))
 233             (and (eq style 'setext) (> level 2)))
 234         (let ((bullet
 235                (if (not (org-export-numbered-headline-p headline info)) "-"
 236                  (concat (number-to-string
 237                           (car (last (org-export-get-headline-number
 238                                       headline info))))
 239                          "."))))
 240           (concat bullet (make-string (- 4 (length bullet)) ?\s) heading tags "\n\n"
 241                   (and contents (replace-regexp-in-string "^" "    " contents)))))
 242        (t (concat (org-md--headline-title style level title anchor tags) contents))))))
 243
 244
 245 ;; Headline Title
 246
 247 (defun org-md--headline-title (style level title &optional anchor tags)
 248   "Generate a headline title in the preferred Markdown headline style.
 249 STYLE is the preferred style (`atx' or `setext').  LEVEL is the
 250 header level.  TITLE is the headline title.  ANCHOR is the HTML
 251 anchor tag for the section as a string.  TAGS are the tags set on
 252 the section."
 253   (let ((anchor-lines (and anchor (concat anchor "\n\n"))))
 254     ;; Use "Setext" style
 255     (if (and (eq style 'setext) (< level 3))
 256         (let* ((underline-char (if (= level 1) ?= ?-))
 257                (underline (concat (make-string (length title) underline-char)
 258                                   "\n")))
 259           (concat "\n" anchor-lines title tags "\n" underline "\n"))
 260         ;; Use "Atx" style
 261         (let ((level-mark (make-string level ?#)))
 262           (concat "\n" anchor-lines level-mark " " title tags "\n\n")))))
 263
 264 ;;;; Horizontal Rule
 265
 266 (defun org-md-horizontal-rule (_horizontal-rule _contents _info)
 267   "Transcode HORIZONTAL-RULE element into Markdown format.
 268 CONTENTS is the horizontal rule contents.  INFO is a plist used
 269 as a communication channel."
 270   "---")
 271
 272
 273 ;;;; Italic
 274
 275 (defun org-md-italic (_italic contents _info)
 276   "Transcode ITALIC object into Markdown format.
 277 CONTENTS is the text within italic markup.  INFO is a plist used
 278 as a communication channel."
 279   (format "*%s*" contents))
 280
 281
 282 ;;;; Item
 283
 284 (defun org-md-item (item contents info)
 285   "Transcode ITEM element into Markdown format.
 286 CONTENTS is the item contents.  INFO is a plist used as
 287 a communication channel."
 288   (let* ((type (org-element-property :type (org-export-get-parent item)))
 289          (struct (org-element-property :structure item))
 290          (bullet (if (not (eq type 'ordered)) "-"
 291                    (concat (number-to-string
 292                             (car (last (org-list-get-item-number
 293                                         (org-element-property :begin item)
 294                                         struct
 295                                         (org-list-prevs-alist struct)
 296                                         (org-list-parents-alist struct)))))
 297                            "."))))
 298     (concat bullet
 299             (make-string (- 4 (length bullet)) ? )
 300             (pcase (org-element-property :checkbox item)
 301               (`on "[X] ")
 302               (`trans "[-] ")
 303               (`off "[ ] "))
 304             (let ((tag (org-element-property :tag item)))
 305               (and tag (format "**%s:** "(org-export-data tag info))))
 306             (and contents
 307                  (org-trim (replace-regexp-in-string "^" "    " contents))))))
 308
 309
 310
 311 ;;;; Keyword
 312
 313 (defun org-md-keyword (keyword contents info)
 314   "Transcode a KEYWORD element into Markdown format.
 315 CONTENTS is nil.  INFO is a plist used as a communication
 316 channel."
 317   (if (member (org-element-property :key keyword) '("MARKDOWN" "MD"))
 318       (org-element-property :value keyword)
 319     (org-export-with-backend 'html keyword contents info)))
 320
 321
 322 ;;;; Line Break
 323
 324 (defun org-md-line-break (_line-break _contents _info)
 325   "Transcode LINE-BREAK object into Markdown format.
 326 CONTENTS is nil.  INFO is a plist used as a communication
 327 channel."
 328   "  \n")
 329
 330
 331 ;;;; Link
 332
 333 (defun org-md-link (link contents info)
 334   "Transcode LINE-BREAK object into Markdown format.
 335 CONTENTS is the link's description.  INFO is a plist used as
 336 a communication channel."
 337   (let ((link-org-files-as-md
 338          (lambda (raw-path)
 339            ;; Treat links to `file.org' as links to `file.md'.
 340            (if (string= ".org" (downcase (file-name-extension raw-path ".")))
 341                (concat (file-name-sans-extension raw-path) ".md")
 342              raw-path)))
 343         (type (org-element-property :type link)))
 344     (cond
 345      ;; Link type is handled by a special function.
 346      ((org-export-custom-protocol-maybe link contents 'md))
 347      ((member type '("custom-id" "id" "fuzzy"))
 348       (let ((destination (if (string= type "fuzzy")
 349                              (org-export-resolve-fuzzy-link link info)
 350                            (org-export-resolve-id-link link info))))
 351         (pcase (org-element-type destination)
 352           (`plain-text                  ; External file.
 353            (let ((path (funcall link-org-files-as-md destination)))
 354              (if (not contents) (format "<%s>" path)
 355                (format "[%s](%s)" contents path))))
 356           (`headline
 357            (format
 358             "[%s](#%s)"
 359             ;; Description.
 360             (cond ((org-string-nw-p contents))
 361                   ((org-export-numbered-headline-p destination info)
 362                    (mapconcat #'number-to-string
 363                               (org-export-get-headline-number destination info)
 364                               "."))
 365                   (t (org-export-data (org-element-property :title destination)
 366                                       info)))
 367             ;; Reference.
 368             (or (org-element-property :CUSTOM_ID destination)
 369                 (org-export-get-reference destination info))))
 370           (_
 371            (let ((description
 372                   (or (org-string-nw-p contents)
 373                       (let ((number (org-export-get-ordinal destination info)))
 374                         (cond
 375                          ((not number) nil)
 376                          ((atom number) (number-to-string number))
 377                          (t (mapconcat #'number-to-string number ".")))))))
 378              (when description
 379                (format "[%s](#%s)"
 380                        description
 381                        (org-export-get-reference destination info))))))))
 382      ((org-export-inline-image-p link org-html-inline-image-rules)
 383       (let ((path (let ((raw-path (org-element-property :path link)))
 384                     (if (not (file-name-absolute-p raw-path)) raw-path
 385                       (expand-file-name raw-path))))
 386             (caption (org-export-data
 387                       (org-export-get-caption
 388                        (org-export-get-parent-element link)) info)))
 389         (format "![img](%s)"
 390                 (if (not (org-string-nw-p caption)) path
 391                   (format "%s \"%s\"" path caption)))))
 392      ((string= type "coderef")
 393       (let ((ref (org-element-property :path link)))
 394         (format (org-export-get-coderef-format ref contents)
 395                 (org-export-resolve-coderef ref info))))
 396      ((equal type "radio") contents)
 397      (t (let* ((raw-path (org-element-property :path link))
 398                (path
 399                 (cond
 400                  ((member type '("http" "https" "ftp"))
 401                   (concat type ":" raw-path))
 402                  ((string= type "file")
 403                   (org-export-file-uri (funcall link-org-files-as-md raw-path)))
 404                  (t raw-path))))
 405           (if (not contents) (format "<%s>" path)
 406             (format "[%s](%s)" contents path)))))))
 407
 408
 409 ;;;; Node Property
 410
 411 (defun org-md-node-property (node-property _contents _info)
 412   "Transcode a NODE-PROPERTY element into Markdown syntax.
 413 CONTENTS is nil.  INFO is a plist holding contextual
 414 information."
 415   (format "%s:%s"
 416           (org-element-property :key node-property)
 417           (let ((value (org-element-property :value node-property)))
 418             (if value (concat " " value) ""))))
 419
 420
 421 ;;;; Paragraph
 422
 423 (defun org-md-paragraph (paragraph contents _info)
 424   "Transcode PARAGRAPH element into Markdown format.
 425 CONTENTS is the paragraph contents.  INFO is a plist used as
 426 a communication channel."
 427   (let ((first-object (car (org-element-contents paragraph))))
 428     ;; If paragraph starts with a #, protect it.
 429     (if (and (stringp first-object) (string-prefix-p "#" first-object))
 430         (concat "\\" contents)
 431       contents)))
 432
 433
 434 ;;;; Plain List
 435
 436 (defun org-md-plain-list (_plain-list contents _info)
 437   "Transcode PLAIN-LIST element into Markdown format.
 438 CONTENTS is the plain-list contents.  INFO is a plist used as
 439 a communication channel."
 440   contents)
 441
 442
 443 ;;;; Plain Text
 444
 445 (defun org-md-plain-text (text info)
 446   "Transcode a TEXT string into Markdown format.
 447 TEXT is the string to transcode.  INFO is a plist holding
 448 contextual information."
 449   (when (plist-get info :with-smart-quotes)
 450     (setq text (org-export-activate-smart-quotes text :html info)))
 451   ;; Protect ambiguous #.  This will protect # at the beginning of
 452   ;; a line, but not at the beginning of a paragraph.  See
 453   ;; `org-md-paragraph'.
 454   (setq text (replace-regexp-in-string "\n#" "\n\\\\#" text))
 455   ;; Protect ambiguous !
 456   (setq text (replace-regexp-in-string "\\(!\\)\\[" "\\\\!" text nil nil 1))
 457   ;; Protect `, *, _ and \
 458   (setq text (replace-regexp-in-string "[`*_\\]" "\\\\\\&" text))
 459   ;; Handle special strings, if required.
 460   (when (plist-get info :with-special-strings)
 461     (setq text (org-html-convert-special-strings text)))
 462   ;; Handle break preservation, if required.
 463   (when (plist-get info :preserve-breaks)
 464     (setq text (replace-regexp-in-string "[ \t]*\n" "  \n" text)))
 465   ;; Return value.
 466   text)
 467
 468
 469 ;;;; Property Drawer
 470
 471 (defun org-md-property-drawer (_property-drawer contents _info)
 472   "Transcode a PROPERTY-DRAWER element into Markdown format.
 473 CONTENTS holds the contents of the drawer.  INFO is a plist
 474 holding contextual information."
 475   (and (org-string-nw-p contents)
 476        (replace-regexp-in-string "^" "    " contents)))
 477
 478
 479 ;;;; Quote Block
 480
 481 (defun org-md-quote-block (_quote-block contents _info)
 482   "Transcode QUOTE-BLOCK element into Markdown format.
 483 CONTENTS is the quote-block contents.  INFO is a plist used as
 484 a communication channel."
 485   (replace-regexp-in-string
 486    "^" "> "
 487    (replace-regexp-in-string "\n\\'" "" contents)))
 488
 489
 490 ;;;; Section
 491
 492 (defun org-md-section (_section contents _info)
 493   "Transcode SECTION element into Markdown format.
 494 CONTENTS is the section contents.  INFO is a plist used as
 495 a communication channel."
 496   contents)
 497
 498
 499 ;;;; Template
 500
 501 (defun org-md--footnote-formatted (footnote info)
 502   "Formats a single footnote entry FOOTNOTE.
 503 FOOTNOTE is a cons cell of the form (number . definition).
 504 INFO is a plist with contextual information."
 505   (let* ((fn-num (car footnote))
 506          (fn-text (cdr footnote))
 507          (fn-format (plist-get info :md-footnote-format))
 508          (fn-anchor (format "fn.%d" fn-num))
 509          (fn-href (format " href=\"#fnr.%d\"" fn-num))
 510          (fn-link-to-ref (org-html--anchor fn-anchor fn-num fn-href info)))
 511     (concat (format fn-format fn-link-to-ref) " " fn-text "\n")))
 512
 513 (defun org-md--footnote-section (info)
 514   "Format the footnote section.
 515 INFO is a plist used as a communication channel."
 516   (let* ((fn-alist (org-export-collect-footnote-definitions info))
 517          (fn-alist (cl-loop for (n _type raw) in fn-alist collect
 518                             (cons n (org-trim (org-export-data raw info)))))
 519          (headline-style (plist-get info :md-headline-style))
 520          (section-title (org-html--translate "Footnotes" info)))
 521     (when fn-alist
 522       (format (plist-get info :md-footnotes-section)
 523               (org-md--headline-title headline-style 1 section-title)
 524               (mapconcat (lambda (fn) (org-md--footnote-formatted fn info))
 525                          fn-alist
 526                          "\n")))))
 527
 528 (defun org-md-inner-template (contents info)
 529   "Return body of document after converting it to Markdown syntax.
 530 CONTENTS is the transcoded contents string.  INFO is a plist
 531 holding export options."
 532   ;; Make sure CONTENTS is separated from table of contents and
 533   ;; footnotes with at least a blank line.
 534   (concat
 535    ;; Table of contents.
 536    (let ((depth (plist-get info :with-toc)))
 537      (when depth (org-html-toc depth info)))
 538    ;; Document contents.
 539    contents
 540    "\n"
 541    ;; Footnotes section.
 542    (org-md--footnote-section info)))
 543
 544 (defun org-md-template (contents _info)
 545   "Return complete document string after Markdown conversion.
 546 CONTENTS is the transcoded contents string.  INFO is a plist used
 547 as a communication channel."
 548   contents)
 549
 550
 551 \f
 552 ;;; Interactive function
 553
 554 ;;;###autoload
 555 (defun org-md-export-as-markdown (&optional async subtreep visible-only)
 556   "Export current buffer to a Markdown buffer.
 557
 558 If narrowing is active in the current buffer, only export its
 559 narrowed part.
 560
 561 If a region is active, export that region.
 562
 563 A non-nil optional argument ASYNC means the process should happen
 564 asynchronously.  The resulting buffer should be accessible
 565 through the `org-export-stack' interface.
 566
 567 When optional argument SUBTREEP is non-nil, export the sub-tree
 568 at point, extracting information from the headline properties
 569 first.
 570
 571 When optional argument VISIBLE-ONLY is non-nil, don't export
 572 contents of hidden elements.
 573
 574 Export is done in a buffer named \"*Org MD Export*\", which will
 575 be displayed when `org-export-show-temporary-export-buffer' is
 576 non-nil."
 577   (interactive)
 578   (org-export-to-buffer 'md "*Org MD Export*"
 579     async subtreep visible-only nil nil (lambda () (text-mode))))
 580
 581 ;;;###autoload
 582 (defun org-md-convert-region-to-md ()
 583   "Assume the current region has Org syntax, and convert it to Markdown.
 584 This can be used in any buffer.  For example, you can write an
 585 itemized list in Org syntax in a Markdown buffer and use
 586 this command to convert it."
 587   (interactive)
 588   (org-export-replace-region-by 'md))
 589
 590
 591 ;;;###autoload
 592 (defun org-md-export-to-markdown (&optional async subtreep visible-only)
 593   "Export current buffer to a Markdown file.
 594
 595 If narrowing is active in the current buffer, only export its
 596 narrowed part.
 597
 598 If a region is active, export that region.
 599
 600 A non-nil optional argument ASYNC means the process should happen
 601 asynchronously.  The resulting file should be accessible through
 602 the `org-export-stack' interface.
 603
 604 When optional argument SUBTREEP is non-nil, export the sub-tree
 605 at point, extracting information from the headline properties
 606 first.
 607
 608 When optional argument VISIBLE-ONLY is non-nil, don't export
 609 contents of hidden elements.
 610
 611 Return output file's name."
 612   (interactive)
 613   (let ((outfile (org-export-output-file-name ".md" subtreep)))
 614     (org-export-to-file 'md outfile async subtreep visible-only)))
 615
 616 ;;;###autoload
 617 (defun org-md-publish-to-md (plist filename pub-dir)
 618   "Publish an org file to Markdown.
 619
 620 FILENAME is the filename of the Org file to be published.  PLIST
 621 is the property list for the given project.  PUB-DIR is the
 622 publishing directory.
 623
 624 Return output file name."
 625   (org-publish-org-to 'md filename ".md" plist pub-dir))
 626
 627 (provide 'ox-md)
 628
 629 ;; Local variables:
 630 ;; generated-autoload-file: "org-loaddefs.el"
 631 ;; End:
 632
 633 ;;; ox-md.el ends here