ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/org/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/org/ox.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.1
;;; with all optimizations.
;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
(< (aref emacs-version (1- (length emacs-version))) ?A)
(string-lessp emacs-version "23")
(error "`%s' was compiled for Emacs 23 or later" #$))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require org-element org-macro ob-exp] 2)
#@55 Maximum nesting depth for headlines, counting from 0.
(defconst org-export-max-depth 19 (#$ . 505))
#@1220 Alist between export properties and ways to set them.
The CAR of the alist is the property name, and the CDR is a list
like (KEYWORD OPTION DEFAULT BEHAVIOR) where:
KEYWORD is a string representing a buffer keyword, or nil. Each
property defined this way can also be set, during subtree
export, through a headline property named after the keyword
with the "EXPORT_" prefix (i.e. DATE keyword and EXPORT_DATE
property).
OPTION is a string that could be found in an #+OPTIONS: line.
DEFAULT is the default value for the property.
BEHAVIOR determines how Org should handle multiple keywords for
the same property. It is a symbol among:
nil Keep old value and discard the new one.
t Replace old value with the new one.
`space' Concatenate the values, separating them with a space.
`newline' Concatenate the values, separating them with
a newline.
`split' Split values at white spaces, and cons them to the
previous list.
Values set through KEYWORD and OPTION have precedence over
DEFAULT.
All these properties should be back-end agnostic. Back-end
specific properties are set through `org-export-define-backend'.
Properties redefined there have precedence over these.
(defconst org-export-options-alist '((:author "AUTHOR" nil user-full-name t) (:creator "CREATOR" nil org-export-creator-string) (:date "DATE" nil nil t) (:description "DESCRIPTION" nil nil newline) (:email "EMAIL" nil user-mail-address t) (:exclude-tags "EXCLUDE_TAGS" nil org-export-exclude-tags split) (:headline-levels nil "H" org-export-headline-levels) (:keywords "KEYWORDS" nil nil space) (:language "LANGUAGE" nil org-export-default-language t) (:preserve-breaks nil "\\n" org-export-preserve-breaks) (:section-numbers nil "num" org-export-with-section-numbers) (:select-tags "SELECT_TAGS" nil org-export-select-tags split) (:time-stamp-file nil "timestamp" org-export-time-stamp-file) (:title "TITLE" nil nil space) (:with-archived-trees nil "arch" org-export-with-archived-trees) (:with-author nil "author" org-export-with-author) (:with-clocks nil "c" org-export-with-clocks) (:with-creator nil "creator" org-export-with-creator) (:with-date nil "date" org-export-with-date) (:with-drawers nil "d" org-export-with-drawers) (:with-email nil "email" org-export-with-email) (:with-emphasize nil "*" org-export-with-emphasize) (:with-entities nil "e" org-export-with-entities) (:with-fixed-width nil ":" org-export-with-fixed-width) (:with-footnotes nil "f" org-export-with-footnotes) (:with-inlinetasks nil "inline" org-export-with-inlinetasks) (:with-latex nil "tex" org-export-with-latex) (:with-planning nil "p" org-export-with-planning) (:with-priority nil "pri" org-export-with-priority) (:with-smart-quotes nil "'" org-export-with-smart-quotes) (:with-special-strings nil "-" org-export-with-special-strings) (:with-statistics-cookies nil "stat" org-export-with-statistics-cookies) (:with-sub-superscript nil "^" org-export-with-sub-superscripts) (:with-toc nil "toc" org-export-with-toc) (:with-tables nil "|" org-export-with-tables) (:with-tags nil "tags" org-export-with-tags) (:with-tasks nil "tasks" org-export-with-tasks) (:with-timestamps nil "<" org-export-with-timestamps) (:with-todo-keywords nil "todo" org-export-with-todo-keywords)) (#$ . 613))
#@213 List of in-buffer keywords that require special treatment.
These keywords are not directly associated to a property. The
way they are handled must be hard-coded into
`org-export--get-inbuffer-options' function.
(defconst org-export-special-keywords '("FILETAGS" "SETUPFILE" "OPTIONS") (#$ . 3910))
#@463 Alist between filters properties and initial values.
The key of each association is a property name accessible through
the communication channel. Its value is a configurable global
variable defining initial filters.
This list is meant to install user specified filters. Back-end
developers may install their own filters using
`org-export-define-backend'. Filters defined there will always
be prepended to the current list, so they always get applied
first.
(defconst org-export-filters-alist '((:filter-bold . org-export-filter-bold-functions) (:filter-babel-call . org-export-filter-babel-call-functions) (:filter-center-block . org-export-filter-center-block-functions) (:filter-clock . org-export-filter-clock-functions) (:filter-code . org-export-filter-code-functions) (:filter-comment . org-export-filter-comment-functions) (:filter-comment-block . org-export-filter-comment-block-functions) (:filter-diary-sexp . org-export-filter-diary-sexp-functions) (:filter-drawer . org-export-filter-drawer-functions) (:filter-dynamic-block . org-export-filter-dynamic-block-functions) (:filter-entity . org-export-filter-entity-functions) (:filter-example-block . org-export-filter-example-block-functions) (:filter-export-block . org-export-filter-export-block-functions) (:filter-export-snippet . org-export-filter-export-snippet-functions) (:filter-final-output . org-export-filter-final-output-functions) (:filter-fixed-width . org-export-filter-fixed-width-functions) (:filter-footnote-definition . org-export-filter-footnote-definition-functions) (:filter-footnote-reference . org-export-filter-footnote-reference-functions) (:filter-headline . org-export-filter-headline-functions) (:filter-horizontal-rule . org-export-filter-horizontal-rule-functions) (:filter-inline-babel-call . org-export-filter-inline-babel-call-functions) (:filter-inline-src-block . org-export-filter-inline-src-block-functions) (:filter-inlinetask . org-export-filter-inlinetask-functions) (:filter-italic . org-export-filter-italic-functions) (:filter-item . org-export-filter-item-functions) (:filter-keyword . org-export-filter-keyword-functions) (:filter-latex-environment . org-export-filter-latex-environment-functions) (:filter-latex-fragment . org-export-filter-latex-fragment-functions) (:filter-line-break . org-export-filter-line-break-functions) (:filter-link . org-export-filter-link-functions) (:filter-node-property . org-export-filter-node-property-functions) (:filter-options . org-export-filter-options-functions) (:filter-paragraph . org-export-filter-paragraph-functions) (:filter-parse-tree . org-export-filter-parse-tree-functions) (:filter-plain-list . org-export-filter-plain-list-functions) (:filter-plain-text . org-export-filter-plain-text-functions) (:filter-planning . org-export-filter-planning-functions) (:filter-property-drawer . org-export-filter-property-drawer-functions) (:filter-quote-block . org-export-filter-quote-block-functions) (:filter-quote-section . org-export-filter-quote-section-functions) (:filter-radio-target . org-export-filter-radio-target-functions) (:filter-section . org-export-filter-section-functions) (:filter-special-block . org-export-filter-special-block-functions) (:filter-src-block . org-export-filter-src-block-functions) (:filter-statistics-cookie . org-export-filter-statistics-cookie-functions) (:filter-strike-through . org-export-filter-strike-through-functions) (:filter-subscript . org-export-filter-subscript-functions) (:filter-superscript . org-export-filter-superscript-functions) (:filter-table . org-export-filter-table-functions) (:filter-table-cell . org-export-filter-table-cell-functions) (:filter-table-row . org-export-filter-table-row-functions) (:filter-target . org-export-filter-target-functions) (:filter-timestamp . org-export-filter-timestamp-functions) (:filter-underline . org-export-filter-underline-functions) (:filter-verbatim . org-export-filter-verbatim-functions) (:filter-verse-block . org-export-filter-verse-block-functions)) (#$ . 4216))
#@351 Default rule for link matching an inline image.
This rule applies to links with no description. By default, it
will be considered as an inline image if it targets a local file
whose extension is either "png", "jpeg", "jpg", "gif",
"tiff", "tif", "xbm", "xpm", "pbm", "pgm" or "ppm".
See `org-export-inline-image-p' for more information about
rules.
(defconst org-export-default-inline-image-rule (byte-code "\300\301\302\303\"BC\207" ["file" format "\\.%s\\'" "\\(gif\\|jp\\(?:e?g\\)\\|p\\(?:bm\\|gm\\|ng\\|pm\\)\\|tiff?\\|x\\(?:[bp]m\\)\\)"] 4) (#$ . 8252))
#@323 Non-nil means asynchronous export process should leave data behind.
This data is found in the appropriate "*Org Export Process*"
buffer, and in files prefixed with "org-export-process" and
located in `temporary-file-directory'.
When non-nil, it will also set `debug-on-error' to a non-nil
value in the external process.
(defvar org-export-async-debug nil (#$ . 8819))
#@379 Record asynchronously generated export results and processes.
This is an alist: its CAR is the source of the
result (destination file or buffer for a finished process,
original buffer for a running one) and its CDR is a list
containing the back-end used, as a symbol, and either a process
or the time at which it finished. It is used to build the menu
from `org-export-stack'.
(defvar org-export-stack-contents nil (#$ . 9196))
#@160 List of backends currently available in the exporter.
This variable is set with `org-export-define-backend' and
`org-export-define-derived-backend' functions.
(defvar org-export--registered-backends nil (#$ . 9632))
#@148 Last command called from the dispatcher.
The value should be a list. Its CAR is the action, as a symbol,
and its CDR is a list of export options.
(defvar org-export-dispatch-last-action nil (#$ . 9855))
#@228 The position where the last export command was created using the dispatcher.
This marker will be used with `C-u C-c C-e' to make sure export repetition
uses the same subtree if the previous command was restricted to a subtree.
(defvar org-export-dispatch-last-position (make-marker) (#$ . 10066))
#@328 Name, if any, of the back-end used during an export process.
Its value is a symbol such as `html', `latex', `ascii', or nil if
the back-end is anonymous (see `org-export-create-backend') or if
there is no export process in progress.
It can be used to teach Babel blocks how to act differently
according to the back-end used.
(defvar org-export-current-backend nil (#$ . 10370))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\302\311\304\312\306\301&\210\313\314\315\316\306\310\317\320&\210\313\321\322\323\306\310\317\324&\210\313\325\302\326\306\310\317\324&\210\313\327\330\331\306\310\317\332&\210\313\333\322\334\306\310\317\324&\210\313\335\302\336\306\310\317\337&\210\313\340\341\342\306\310\317\343&\210\313\344\345\346\306\310\347\350\351\352\317\353& \210\313\354\302\355\306\310\317\324&\210\313\356\322\357\306\310\317\324&\210\313\360\361\362\306\310\317\363&\210\313\364\322\365\306\310\317\324&\210\313\366\322\367\306\310\317\324&\210\313\370\322\371\306\310\347\350\351\372\317\373& \210\313\374\375\376\306\310\317\377&\210\313\201@ \201A \201B \306\310\317\201C &\210\313\201D \302\201E \306\310\317\324&\210\313\201F \322\201G \306\310\317\324&\210\313\201H \322\201I \306\310\347\350\351\201J \317\324& \210\313\201K \302\201L \306\310\347\350\351\201M \317\324& \210\313\201N \302\201O \306\310\317\324&\210\313\201P \322\201Q \306\310\317\324&\210\313\201R \201S \201T \306\310\317\201U &\210\313\201V \302\201W \306\310\347\350\351\201X \317\324& \210\313\201Y \322\201Z \306\310\317\324&\210\313\201[ \322\201\\ \306\310\347\350\351\201] \317\324& \210\313\201^ \322\201_ \306\310\347\350\351\201` \317\201a & \210\313\201b \322\201c \306\310\317\201d &\210\313\201e \322\201f \306\310\317\324&\210\313\201g \322\201h \306\310\317\201i &\210\313\201j \322\201k \306\310\317\201l &\210\313\201m \322\201n \306\310\317\324&\210\313\201o \322\201p \306\310\317\201q &\210\313\201r \322\201s \306\310\317\324&\210\313\201t \302\201u \306\310\347\350\351\201v \317\324& \210\313\201w \302\201x \306\310\347\350\351\201y \317\201z & \210\313\201{ \302\201| \306\310\347\350\351\201} \317\201~ & \210\313\201 \201\200 \201\201 \306\310\347\201\202 \317\201\203 & \210\313\201\204 \201\205 \201\206 \306\310\317\201\207 &\210\313\201\210 \322\201\211 \306\310\317\324&\210\313\201\212 \302\201\213 \306\310\347\350\351\201\214 \317\324& \210\313\201\215 \201\216 \201\217 \306\310\347\350\351\201\220 \317\201\221 & \210\313\201\222 \302\201\223 \306\310\347\350\351\201\224 \317\324& \207" [custom-declare-group org-export nil "Options for exporting Org mode files." :tag "Org Export" :group org org-export-general "General options for export engine." "Org Export General" custom-declare-variable org-export-with-archived-trees 'headline "Whether sub-trees with the ARCHIVE tag should be exported.\n\nThis can have three different values:\nnil Do not export, pretend this tree is not present.\nt Do export the entire tree.\n`headline' Only export the headline, but skip the tree below it.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"arch:nil\"." :type (choice (const :tag "Not at all" nil) (const :tag "Headline only" headline) (const :tag "Entirely" t)) org-export-with-author t "Non-nil means insert author name into the exported file.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"author:nil\"." boolean org-export-with-clocks "Non-nil means export CLOCK keywords.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"c:t\"." org-export-with-creator 'comment "Non-nil means the postamble should contain a creator sentence.\n\nThe sentence can be set in `org-export-creator-string' and\ndefaults to \"Generated by Org mode XX in Emacs XXX.\".\n\nIf the value is `comment' insert it as a comment." (choice (const :tag "No creator sentence" nil) (const :tag "Sentence as a comment" comment) (const :tag "Insert the sentence" t)) org-export-with-date "Non-nil means insert date in the exported document.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"date:nil\"." org-export-date-timestamp-format "Time-stamp format string to use for DATE keyword.\n\nThe format string, when specified, only applies if date consists\nin a single time-stamp. Otherwise its value will be ignored.\n\nSee `format-time-string' for details on how to build this\nstring." (choice (string :tag "Time-stamp format string") (const :tag "No format string" nil)) org-export-creator-string (format "Emacs %s (Org mode %s)" emacs-version (if (fboundp 'org-version) (org-version) "unknown version")) "Information about the creator of the document.\nThis option can also be set on with the CREATOR keyword." (string :tag "Creator string") org-export-with-drawers '(not "LOGBOOK") "Non-nil means export contents of standard drawers.\n\nWhen t, all drawers are exported. This may also be a list of\ndrawer names to export. If that list starts with `not', only\ndrawers with such names will be ignored.\n\nThis variable doesn't apply to properties drawers.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"d:nil\"." :version "24.4" :package-version (Org . "8.0") (choice (const :tag "All drawers" t) (const :tag "None" nil) (repeat :tag "Selected drawers" (string :tag "Drawer name")) (list :tag "Ignored drawers" (const :format "" not) (repeat :tag "Specify names of drawers to ignore during export" :inline t (string :tag "Drawer name")))) org-export-with-email "Non-nil means insert author email into the exported file.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"email:t\"." org-export-with-emphasize "Non-nil means interpret *word*, /word/, _word_ and +word+.\n\nIf the export target supports emphasizing text, the word will be\ntypeset in bold, italic, with an underline or strike-through,\nrespectively.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"*:nil\"." org-export-exclude-tags '("noexport") "Tags that exclude a tree from export.\n\nAll trees carrying any of these tags will be excluded from\nexport. This is without condition, so even subtrees inside that\ncarry one of the `org-export-select-tags' will be removed.\n\nThis option can also be set with the EXCLUDE_TAGS keyword." (repeat (string :tag "Tag")) org-export-with-fixed-width "Non-nil means lines starting with \":\" will be in fixed width font.\n\nThis can be used to have pre-formatted text, fragments of code\netc. For example:\n : ;; Some Lisp examples\n : (while (defc cnt)\n : (ding))\nwill be looking just like this in also HTML. See also the QUOTE\nkeyword. Not all export backends support this.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"::nil\"." org-export-with-footnotes "Non-nil means Org footnotes should be exported.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"f:nil\"." org-export-with-latex "Non-nil means process LaTeX environments and fragments.\n\nThis option can also be set with the OPTIONS line,\ne.g. \"tex:verbatim\". Allowed values are:\n\nnil Ignore math snippets.\n`verbatim' Keep everything in verbatim.\nt Allow export of math snippets." (Org . "8.0") (choice (const :tag "Do not process math in any way" nil) (const :tag "Interpret math snippets" t) (const :tag "Leave math verbatim" verbatim)) org-export-headline-levels 3 "The last level which is still exported as a headline.\n\nInferior levels will usually produce itemize or enumerate lists\nwhen exported, but back-end behavior may differ.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"H:2\"." integer org-export-default-language "en" "The default language for export and clocktable translations, as a string.\nThis may have an association in\n`org-clock-clocktable-language-setup',\n`org-export-smart-quotes-alist' and `org-export-dictionary'.\nThis option can also be set with the LANGUAGE keyword." (string :tag "Language") org-export-preserve-breaks "Non-nil means preserve all line breaks when exporting.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"\\n:t\"." org-export-with-entities "Non-nil means interpret entities when exporting.\n\nFor example, HTML export converts \\alpha to α and \\AA to\nÅ.\n\nFor a list of supported names, see the constant `org-entities'\nand the user option `org-entities-user'.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"e:nil\"." org-export-with-inlinetasks "Non-nil means inlinetasks should be exported.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"inline:nil\"." (Org . "8.0") org-export-with-planning "Non-nil means include planning info in export.\n\nPlanning info is the line containing either SCHEDULED:,\nDEADLINE:, CLOSED: time-stamps, or a combination of them.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"p:t\"." (Org . "8.0") org-export-with-priority "Non-nil means include priority cookies in export.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"pri:t\"." org-export-with-section-numbers "Non-nil means add section numbers to headlines when exporting.\n\nWhen set to an integer n, numbering will only happen for\nheadlines whose relative level is higher or equal to n.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"num:t\"." org-export-select-tags '("export") "Tags that select a tree for export.\n\nIf any such tag is found in a buffer, all trees that do not carry\none of these tags will be ignored during export. Inside trees\nthat are selected like this, you can still deselect a subtree by\ntagging it with one of the `org-export-exclude-tags'.\n\nThis option can also be set with the SELECT_TAGS keyword." (repeat (string :tag "Tag")) org-export-with-smart-quotes "Non-nil means activate smart quotes during export.\nThis option can also be set with the OPTIONS keyword,\ne.g., \"':t\".\n\nWhen setting this to non-nil, you need to take care of\nusing the correct Babel package when exporting to LaTeX.\nE.g., you can load Babel for french like this:\n\n#+LATEX_HEADER: \\usepackage[french]{babel}" (Org . "8.0") org-export-with-special-strings "Non-nil means interpret \"\\-\", \"--\" and \"---\" for export.\n\nWhen this option is turned on, these strings will be exported as:\n\n Org HTML LaTeX UTF-8\n -----+----------+--------+-------\n \\- ­ \\-\n -- – -- –\n --- — --- —\n ... … \\ldots …\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"-:nil\"." org-export-with-statistics-cookies "Non-nil means include statistics cookies in export.\nThis option can also be set with the OPTIONS keyword,\ne.g. \"stat:nil\"" (Org . "8.0") org-export-with-sub-superscripts "Non-nil means interpret \"_\" and \"^\" for export.\n\nIf you want to control how Org displays those characters, see\n`org-use-sub-superscripts'. `org-export-with-sub-superscripts'\nused to be an alias for `org-use-sub-superscripts' in Org <8.0,\nit is not anymore.\n\nWhen this option is turned on, you can use TeX-like syntax for\nsub- and superscripts and see them exported correctly.\n\nYou can also set the option with #+OPTIONS: ^:t\n\nSeveral characters after \"_\" or \"^\" will be considered as a\nsingle item - so grouping with {} is normally not needed. For\nexample, the following things will be parsed as single sub- or\nsuperscripts:\n\n 10^24 or 10^tau several digits will be considered 1 item.\n 10^-12 or 10^-tau a leading sign with digits or a word\n x^2-y^3 will be read as x^2 - y^3, because items are\n terminated by almost any nonword/nondigit char.\n x_{i^2} or x^(2-i) braces or parenthesis do grouping.\n\nStill, ambiguity is possible. So when in doubt, use {} to enclose\nthe sub/superscript. If you set this variable to the symbol `{}',\nthe braces are *required* in order to trigger interpretations as\nsub/superscript. This can be helpful in documents that need \"_\"\nfrequently in plain text." (Org . "8.0") (choice (const :tag "Interpret them" t) (const :tag "Curly brackets only" {}) (const :tag "Do not interpret them" nil)) org-export-with-toc "Non-nil means create a table of contents in exported files.\n\nThe TOC contains headlines with levels up\nto`org-export-headline-levels'. When an integer, include levels\nup to N in the toc, this may then be different from\n`org-export-headline-levels', but it will not be allowed to be\nlarger than the number of headline levels. When nil, no table of\ncontents is made.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"toc:nil\" or \"toc:3\"." (choice (const :tag "No Table of Contents" nil) (const :tag "Full Table of Contents" t) (integer :tag "TOC to level")) org-export-with-tables "If non-nil, lines starting with \"|\" define a table.\nFor example:\n\n | Name | Address | Birthday |\n |-------------+----------+-----------|\n | Arthur Dent | England | 29.2.2100 |\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"|:nil\"." org-export-with-tags "If nil, do not export tags, just remove them from headlines.\n\nIf this is the symbol `not-in-toc', tags will be removed from\ntable of contents entries, but still be shown in the headlines of\nthe document.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"tags:nil\"." (choice (const :tag "Off" nil) (const :tag "Not in TOC" not-in-toc) (const :tag "On" t)) org-export-with-tasks "Non-nil means include TODO items for export.\n\nThis may have the following values:\nt include tasks independent of state.\n`todo' include only tasks that are not yet done.\n`done' include only tasks that are already done.\nnil ignore all tasks.\nlist of keywords include tasks with these keywords.\n\nThis option can also be set with the OPTIONS keyword,\ne.g. \"tasks:nil\"." (choice (const :tag "All tasks" t) (const :tag "No tasks" nil) (const :tag "Not-done tasks" todo) (const :tag "Only done tasks" done) (repeat :tag "Specific TODO keywords" (string :tag "Keyword"))) org-export-time-stamp-file "Non-nil means insert a time stamp into the exported file.\nThe time stamp shows when the file was created. This option can\nalso be set with the OPTIONS keyword, e.g. \"timestamp:nil\"." org-export-with-timestamps "Non nil means allow timestamps in export.\n\nIt can be set to any of the following values:\n t export all timestamps.\n `active' export active timestamps only.\n `inactive' export inactive timestamps only.\n nil do not export timestamps\n\nThis only applies to timestamps isolated in a paragraph\ncontaining only timestamps. Other timestamps are always\nexported.\n\nThis option can also be set with the OPTIONS keyword, e.g.\n\"<:nil\"." (choice (const :tag "All timestamps" t) (const :tag "Only active timestamps" active) (const :tag "Only inactive timestamps" inactive) (const :tag "No timestamp" nil)) org-export-with-todo-keywords "Non-nil means include TODO keywords in export.\nWhen nil, remove all these keywords from the export. This option\ncan also be set with the OPTIONS keyword, e.g. \"todo:nil\"." org-export-allow-bind-keywords "Non-nil means BIND keywords can define local variable values.\nThis is a potential security risk, which is why the default value\nis nil. You can also allow them through local buffer variables." (Org . "8.0") org-export-snippet-translation-alist "Alist between export snippets back-ends and exporter back-ends.\n\nThis variable allows providing shortcuts for export snippets.\n\nFor example, with a value of ((\"h\" . \"html\")), the\nHTML back-end will recognize the contents of \"@@h:<b>@@\" as\nHTML code while every other back-end will ignore it." (Org . "8.0") (repeat (cons (string :tag "Shortcut") (string :tag "Back-end"))) org-export-coding-system "Coding system for the exported file." (Org . "8.0") coding-system org-export-copy-to-kill-ring 'if-interactive "Non-nil means pushing export output to the kill ring.\nThis variable is ignored during asynchronous export." "24.3" (choice (const :tag "Always" t) (const :tag "When export is done interactively" if-interactive) (const :tag "Never" nil)) org-export-initial-scope 'buffer "The initial scope when exporting with `org-export-dispatch'.\nThis variable can be either set to `buffer' or `subtree'." (choice (const :tag "Export current buffer" buffer) (const :tag "Export current subtree" subtree)) org-export-show-temporary-export-buffer "Non-nil means show buffer after exporting to temp buffer.\nWhen Org exports to a file, the buffer visiting that file is never\nshown, but remains buried. However, when exporting to\na temporary buffer, that buffer is popped up in a second window.\nWhen this variable is nil, the buffer remains buried also in\nthese cases." org-export-in-background "Non-nil means export and publishing commands will run in background.\nResults from an asynchronous export are never displayed\nautomatically. But you can retrieve them with \\[org-export-stack]." (Org . "8.0") org-export-async-init-file user-init-file "File used to initialize external export process.\nValue must be an absolute file name. It defaults to user's\ninitialization file. Though, a specific configuration makes the\nprocess faster and the export more portable." (Org . "8.0") (file :must-match t) org-export-dispatch-use-expert-ui "Non-nil means using a non-intrusive `org-export-dispatch'.\nIn that case, no help buffer is displayed. Though, an indicator\nfor current export scope is added to the prompt (\"b\" when\noutput is restricted to body only, \"s\" when it is restricted to\nthe current subtree, \"v\" when only visible elements are\nconsidered for export, \"f\" when publishing functions should be\npassed the FORCE argument and \"a\" when the export should be\nasynchronous). Also, [?] allows switching back to standard\nmode." (Org . "8.0")] 12)
(defalias 'org-export-backend-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block org-export-backend-p (declare (side-effect-free error-free)) (and (vectorp cl-x) (>= (length cl-x) 8) (memq (aref cl-x 0) cl-struct-org-export-backend-tags) t)) nil] 7])
(put 'org-export-backend-p 'compiler-macro 'org-export-backend-p--cmacro)
(defalias 'org-export-backend-p #[(cl-x) "\302!\205 G\303Y\205 \304H >\205 \305\207" [cl-x cl-struct-org-export-backend-tags vectorp 8 0 t] 2])
(byte-code "\300\301\302\303#\210\304\305\306\301#\207" [function-put org-export-backend-p side-effect-free error-free put org-export-backend cl-deftype-satisfies] 4)
(defalias 'org-export-backend-name--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block org-export-backend-name (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-org-export-backend-tags)) (signal 'wrong-type-argument (list 'org-export-backend cl-x))) (aref cl-x 1)) nil] 7])
(put 'org-export-backend-name 'compiler-macro 'org-export-backend-name--cmacro)
(defalias 'org-export-backend-name #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-org-export-backend-tags 0 signal wrong-type-argument org-export-backend 1] 4])
(function-put 'org-export-backend-name 'side-effect-free t)
(defalias 'org-export-backend-parent--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block org-export-backend-parent (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-org-export-backend-tags)) (signal 'wrong-type-argument (list 'org-export-backend cl-x))) (aref cl-x 2)) nil] 7])
(put 'org-export-backend-parent 'compiler-macro 'org-export-backend-parent--cmacro)
(defalias 'org-export-backend-parent #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-org-export-backend-tags 0 signal wrong-type-argument org-export-backend 2] 4])
(function-put 'org-export-backend-parent 'side-effect-free t)
(defalias 'org-export-backend-transcoders--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block org-export-backend-transcoders (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-org-export-backend-tags)) (signal 'wrong-type-argument (list 'org-export-backend cl-x))) (aref cl-x 3)) nil] 7])
(put 'org-export-backend-transcoders 'compiler-macro 'org-export-backend-transcoders--cmacro)
(defalias 'org-export-backend-transcoders #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-org-export-backend-tags 0 signal wrong-type-argument org-export-backend 3] 4])
(function-put 'org-export-backend-transcoders 'side-effect-free t)
(defalias 'org-export-backend-options--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block org-export-backend-options (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-org-export-backend-tags)) (signal 'wrong-type-argument (list 'org-export-backend cl-x))) (aref cl-x 4)) nil] 7])
(put 'org-export-backend-options 'compiler-macro 'org-export-backend-options--cmacro)
(defalias 'org-export-backend-options #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-org-export-backend-tags 0 signal wrong-type-argument org-export-backend 4] 4])
(function-put 'org-export-backend-options 'side-effect-free t)
(defalias 'org-export-backend-filters--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block org-export-backend-filters (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-org-export-backend-tags)) (signal 'wrong-type-argument (list 'org-export-backend cl-x))) (aref cl-x 5)) nil] 7])
(put 'org-export-backend-filters 'compiler-macro 'org-export-backend-filters--cmacro)
(defalias 'org-export-backend-filters #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-org-export-backend-tags 0 signal wrong-type-argument org-export-backend 5] 4])
(function-put 'org-export-backend-filters 'side-effect-free t)
(defalias 'org-export-backend-blocks--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block org-export-backend-blocks (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-org-export-backend-tags)) (signal 'wrong-type-argument (list 'org-export-backend cl-x))) (aref cl-x 6)) nil] 7])
(put 'org-export-backend-blocks 'compiler-macro 'org-export-backend-blocks--cmacro)
(defalias 'org-export-backend-blocks #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-org-export-backend-tags 0 signal wrong-type-argument org-export-backend 6] 4])
(function-put 'org-export-backend-blocks 'side-effect-free t)
(defalias 'org-export-backend-menu--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block org-export-backend-menu (declare (side-effect-free t)) (or (and (memq (aref cl-x 0) cl-struct-org-export-backend-tags)) (signal 'wrong-type-argument (list 'org-export-backend cl-x))) (aref cl-x 7)) nil] 7])
(put 'org-export-backend-menu 'compiler-macro 'org-export-backend-menu--cmacro)
(defalias 'org-export-backend-menu #[(cl-x) "\302H >\204 \303\304\305D\"\210\306H\207" [cl-x cl-struct-org-export-backend-tags 0 signal wrong-type-argument org-export-backend 7] 4])
(function-put 'org-export-backend-menu 'side-effect-free t)
#@84
(fn CL-WHOLE &cl-quote &key NAME PARENT TRANSCODERS OPTIONS FILTERS BLOCKS MENU)
(defalias 'org-export-create-backend--cmacro #[(cl-whole &rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@ \306\313\"A@ \306\314\"A@ \306\315\"A@ \203f @\316>\203M AA\211\2028 \317>A@\203\\ \320\211\2028 \321\322@\"\210\2026 )\323\324\325\320\320 \n \f
&\f.\207" [#1# name parent transcoders options filters plist-member :name :parent :transcoders :options :filters :blocks :menu (:name :parent :transcoders :options :filters :blocks :menu :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :parent :transcoders :options :filters :blocks :menu)" cl--defsubst-expand (name parent transcoders options filters blocks menu) (cl-block org-export-create-backend "Constructor for objects of type `org-export-backend'." (declare (side-effect-free t)) (vector 'cl-struct-org-export-backend name parent transcoders options filters blocks menu)) blocks menu #2=#:--cl-keys-- cl-whole] 14 (#$ . 33897)])
(put 'org-export-create-backend 'compiler-macro 'org-export-create-backend--cmacro)
#@118 Constructor for objects of type `org-export-backend'.
(fn &key NAME PARENT TRANSCODERS OPTIONS FILTERS BLOCKS MENU)
(defalias 'org-export-create-backend #[(&rest #1=#:--cl-rest--) "\306\307\"A@\306\310\"A@\306\311\"A@\306\312\"A@ \306\313\"A@ \306\314\"A@ \306\315\"A@ \203f @\316>\203M AA\211\2028 \317>A@\203\\ \320\211\2028 \321\322@\"\210\2026 )\323\324 \n \f
&.\207" [#1# name parent transcoders options filters plist-member :name :parent :transcoders :options :filters :blocks :menu (:name :parent :transcoders :options :filters :blocks :menu :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :parent :transcoders :options :filters :blocks :menu)" vector cl-struct-org-export-backend blocks menu #2=#:--cl-keys--] 10 (#$ . 35057)])
(byte-code "\300\301\302\303#\210\304\305\306\307\306\211\310\311\312\303& \207" [function-put org-export-create-backend side-effect-free t cl-struct-define org-export-backend nil cl-structure-object ((cl-tag-slot) (name) (parent) (transcoders) (options) (filters) (blocks) (menu)) cl-struct-org-export-backend-tags cl-struct-org-export-backend] 10)
#@102 Return export back-end named after NAME.
NAME is a symbol. Return nil if no such back-end is found.
(defalias 'org-export-get-backend #[(name) "\30525 \306\211\2053 \n@\211\307H >\204 \310\311\312 D\"\210 \313H\f=\203+ \314\305 \"\210\nA\211\204\f \306*0\207" [org-export--registered-backends b --dolist-tail-- cl-struct-org-export-backend-tags name found nil 0 signal wrong-type-argument org-export-backend 1 throw] 5 (#$ . 36223)])
#@101 Register BACKEND as a known export back-end.
BACKEND is a structure with `org-export-backend' type.
(defalias 'org-export-register-backend #[(backend) "\306H >\204 \307\310\311D\"\210\312H\204 \313\314!\210\306H >\204( \307\310\311D\"\210\315H\211\203; \316\n!\204; \313\317\n\"\210)\306H >\204K \307\310\311D\"\210\320H\321\211 \203f \f@\322\323 \324B\"\210\fA\211\204U *\316\306H >\204w \307\310\311D\"\210\312H!\211 \203\211
>\240\202\220 B\211)\207" [backend cl-struct-org-export-backend-tags parent name --dolist-tail-- old 0 signal wrong-type-argument org-export-backend 1 error "Cannot register a unnamed export back-end" 2 org-export-get-backend "Cannot use unknown \"%s\" back-end as a parent" 6 nil add-to-list org-element-block-name-alist org-element-export-block-parser org-export--registered-backends] 6 (#$ . 36671)])
#@43 Signal an error if BACKEND isn't defined.
(defalias 'org-export-barf-if-invalid-backend #[(backend) "\302!\205 G\303Y\205 \304H >\205 \305?\205 \306\307\"\207" [backend cl-struct-org-export-backend-tags vectorp 8 0 t error "Unknown \"%s\" back-end: Aborting export"] 3 (#$ . 37536)])
#@220 Non-nil if BACKEND is derived from one of BACKENDS.
BACKEND is an export back-end, as returned by, e.g.,
`org-export-create-backend', or a symbol referring to
a registered back-end. BACKENDS is constituted of symbols.
(defalias 'org-export-derived-backend-p #[(backend &rest backends) "9\203 \303!\205p \3042p \305H >\204 \306\307\310D\"\210\311H\203[ \305H >\2045 \306\307\310D\"\210\312H\n>\203B \313\304\314\"\210\303\305H >\204R \306\307\310D\"\210\311H!\211\202 \305H >\204j \306\307\310D\"\210\312H\n>0\207" [backend cl-struct-org-export-backend-tags backends org-export-get-backend exit 0 signal wrong-type-argument org-export-backend 2 1 throw t] 6 (#$ . 37835)])
#@356 Return full translation table for BACKEND.
BACKEND is an export back-end, as return by, e.g,,
`org-export-create-backend'. Return value is an alist where
keys are element or object types, as symbols, and values are
transcoders.
Unlike to `org-export-backend-transcoders', this function
also returns transcoders inherited from parent back-ends,
if any.
(defalias 'org-export-get-all-transcoders #[(backend) "9\203 \304!\205X \305H >\204 \306\307\310D\"\210\311H\312\305H >\2041 \306\307\310D\"\210\313H\211\203V \304\n!\314 \305H >\204N \306\307\310D\"\210\311H\"\202\" *\207" [backend cl-struct-org-export-backend-tags parent transcoders org-export-get-backend 0 signal wrong-type-argument org-export-backend 3 nil 2 append] 6 (#$ . 38535)])
#@301 Return export options for BACKEND.
BACKEND is an export back-end, as return by, e.g,,
`org-export-create-backend'. See `org-export-options-alist'
for the shape of the return value.
Unlike to `org-export-backend-options', this function also
returns options inherited from parent back-ends, if any.
(defalias 'org-export-get-all-options #[(backend) "9\203 \304!\205X \305H >\204 \306\307\310D\"\210\311H\312\305H >\2041 \306\307\310D\"\210\313H\211\203V \304\n!\314 \305H >\204N \306\307\310D\"\210\311H\"\202\" *\207" [backend cl-struct-org-export-backend-tags parent options org-export-get-backend 0 signal wrong-type-argument org-export-backend 4 nil 2 append] 6 (#$ . 39308)])
#@324 Return complete list of filters for BACKEND.
BACKEND is an export back-end, as return by, e.g,,
`org-export-create-backend'. Return value is an alist where
keys are symbols and values lists of functions.
Unlike to `org-export-backend-filters', this function also
returns filters inherited from parent back-ends, if any.
(defalias 'org-export-get-all-filters #[(backend) "9\203 \304!\205X \305H >\204 \306\307\310D\"\210\311H\312\305H >\2041 \306\307\310D\"\210\313H\211\203V \304\n!\314 \305H >\204N \306\307\310D\"\210\311H\"\202\" *\207" [backend cl-struct-org-export-backend-tags parent filters org-export-get-backend 0 signal wrong-type-argument org-export-backend 5 nil 2 append] 6 (#$ . 40018)])
#@4213 Define a new back-end BACKEND.
TRANSCODERS is an alist between object or element types and
functions handling them.
These functions should return a string without any trailing
space, or nil. They must accept three arguments: the object or
element itself, its contents or nil when it isn't recursive and
the property list used as a communication channel.
Contents, when not nil, are stripped from any global indentation
(although the relative one is preserved). They also always end
with a single newline character.
If, for a given type, no function is found, that element or
object type will simply be ignored, along with any blank line or
white space at its end. The same will happen if the function
returns the nil value. If that function returns the empty
string, the type will be ignored, but the blank lines or white
spaces will be kept.
In addition to element and object types, one function can be
associated to the `template' (or `inner-template') symbol and
another one to the `plain-text' symbol.
The former returns the final transcoded string, and can be used
to add a preamble and a postamble to document's body. It must
accept two arguments: the transcoded string and the property list
containing export options. A function associated to `template'
will not be applied if export has option "body-only".
A function associated to `inner-template' is always applied.
The latter, when defined, is to be called on every text not
recognized as an element or an object. It must accept two
arguments: the text string and the information channel. It is an
appropriate place to protect special chars relative to the
back-end.
BODY can start with pre-defined keyword arguments. The following
keywords are understood:
:export-block
String, or list of strings, representing block names that
will not be parsed. This is used to specify blocks that will
contain raw code specific to the back-end. These blocks
still have to be handled by the relative `export-block' type
translator.
:filters-alist
Alist between filters and function, or list of functions,
specific to the back-end. See `org-export-filters-alist' for
a list of all allowed filters. Filters defined here
shouldn't make a back-end test, as it may prevent back-ends
derived from this one to behave properly.
:menu-entry
Menu entry for the export dispatcher. It should be a list
like:
(KEY DESCRIPTION-OR-ORDINAL ACTION-OR-MENU)
where :
KEY is a free character selecting the back-end.
DESCRIPTION-OR-ORDINAL is either a string or a number.
If it is a string, is will be used to name the back-end in
its menu entry. If it is a number, the following menu will
be displayed as a sub-menu of the back-end with the same
KEY. Also, the number will be used to determine in which
order such sub-menus will appear (lowest first).
ACTION-OR-MENU is either a function or an alist.
If it is an action, it will be called with four
arguments (booleans): ASYNC, SUBTREEP, VISIBLE-ONLY and
BODY-ONLY. See `org-export-as' for further explanations on
some of them.
If it is an alist, associations should follow the
pattern:
(KEY DESCRIPTION ACTION)
where KEY, DESCRIPTION and ACTION are described above.
Valid values include:
(?m "My Special Back-end" my-special-export-function)
or
(?l "Export to LaTeX"
(?p "As PDF file" org-latex-export-to-pdf)
(?o "As PDF file and open"
(lambda (a s v b)
(if a (org-latex-export-to-pdf t s v b)
(org-open-file
(org-latex-export-to-pdf nil s v b)))))))
or the following, which will be added to the previous
sub-menu,
(?l 1
((?B "As TEX buffer (Beamer)" org-beamer-export-as-latex)
(?P "As PDF file (Beamer)" org-beamer-export-to-pdf)))
:options-alist
Alist between back-end specific properties introduced in
communication channel and how their value are acquired. See
`org-export-options-alist' for more information about
structure of the values.
(defalias 'org-export-define-backend #[(backend transcoders &rest body) "\306\211\211\211\211 \307
@!\203y
\211A\242 \310\311\"\203=
\211A\242\211 :\2034 \312\313\"\2028 \226C)\202u \310\314\"\203N
\211A\242\202u \310\315\"\203_
\211A\242\202u \310\316\"\203p
\211A\242\202u
\211A\210)\202\n \317\320\321\306 \f\n&!-\207" [contents options menu-entry filters blocks body nil keywordp eql :export-block mapcar upcase :filters-alist :menu-entry :options-alist org-export-register-backend vector cl-struct-org-export-backend #1=#:temp names backend transcoders] 11 (#$ . 40752)])
(function-put 'org-export-define-backend 'lisp-indent-function 1)
#@1678 Create a new back-end as a variant of an existing one.
CHILD is the name of the derived back-end. PARENT is the name of
the parent back-end.
BODY can start with pre-defined keyword arguments. The following
keywords are understood:
:export-block
String, or list of strings, representing block names that
will not be parsed. This is used to specify blocks that will
contain raw code specific to the back-end. These blocks
still have to be handled by the relative `export-block' type
translator.
:filters-alist
Alist of filters that will overwrite or complete filters
defined in PARENT back-end. See `org-export-filters-alist'
for a list of allowed filters.
:menu-entry
Menu entry for the export dispatcher. See
`org-export-define-backend' for more information about the
expected value.
:options-alist
Alist of back-end specific properties that will overwrite or
complete those defined in PARENT back-end. Refer to
`org-export-options-alist' for more information about
structure of the values.
:translate-alist
Alist of element and object types and transcoders that will
overwrite or complete transcode table from PARENT back-end.
Refer to `org-export-define-backend' for detailed information
about transcoders.
As an example, here is how one could define "my-latex" back-end
as a variant of `latex' back-end with a custom template function:
(org-export-define-derived-backend \='my-latex \='latex
:translate-alist \='((template . my-latex-template-fun)))
The back-end could then be called with, for example:
(org-export-to-buffer \='my-latex "*Test my-latex*")
(defalias 'org-export-define-derived-backend #[(child parent &rest body) "\306\211\211\211\211\211 \307@!\203\233 \211A\242 \310\311\"\203D \211A\242\211 :\203; \312\313\"\202? \226C)\202\227 \310\314\"\203W \211A\242\202\227 \310\315\"\203j \211A\242\202\227 \310\316\"\203} \211A\242\202\227 \310\317\"\203\220 \211A\242\202\227 \211A\210)\202\f \320\321\322 \n\f
&!.\207" [contents transcoders options menu-entry filters blocks nil keywordp eql :export-block mapcar upcase :filters-alist :menu-entry :options-alist :translate-alist org-export-register-backend vector cl-struct-org-export-backend body #1=#:temp names child parent] 11 (#$ . 45655)])
(function-put 'org-export-define-derived-backend 'lisp-indent-function 2)
#@399 Collect export options from the current buffer.
Optional argument BACKEND is an export back-end, as returned by
`org-export-create-backend'.
When optional argument SUBTREEP is non-nil, assume the export is
done against the current sub-tree.
Third optional argument EXT-PLIST is a property list with
external parameters overriding Org default settings, but still
inferior to file-local settings.
(defalias 'org-export-get-environment #[(&optional backend subtreep ext-plist) "\306 \307\211\203! @\211@A@\310 !\nL*\210 A\211\204 *\311\312\f!
\313\f!'\2052 \314\f!\315\f\316\317\f!\320\307 (\212\214~\210eb\210\321)\307\322#\203\366 \323 *\324\216\325 *\211 +\211 ,:\204i ,;\205s \326\202s ,@9\205s ,@)\327=\203\362 \330+ , -,;\203\220 \331\332-,#\202\230 \333,A@-\"*\334+ , -,;\203\260 \331\332-,#\202\270 \333,A@-\"*\211 .\205\353 \335.\336+ , -,;\203\331 \331\332-,#\202\341 \333,A@-\"*\307\211\211\211\337\307D&)B(B()\202C (+\340\307 (\212\214~\210eb\210\321\341\307\322#\203o\342 \211 #\211 ,:\204\",;\205,\326\202,,@9\205,,@)\343=\203k\344# , -,;\203I\331\332-,#\202Q\333,A@-\"* /\345/!\211 0\203j/\3460!B(B(*)\202*()\257%\207" [pair --dolist-tail-- value var backend ext-plist org-export--list-bound-variables nil make-local-variable org-combine-plists org-export--get-global-options org-export--get-inbuffer-options org-export--get-subtree-options :back-end :translate-alist org-export-get-all-transcoders :footnote-definition-alist re-search-forward t match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] org-element-at-point plain-text footnote-definition :label get-text-property 0 plist-get :contents-begin org-element--parse-elements :contents-end org-data :id-alist "\\[\\[id:\\S-+?\\]" org-element-context link :path org-id-find-id-file file-relative-name subtreep alist org-footnote-definition-re save-match-data-internal def element property cbeg id file] 21 (#$ . 48128)])
#@214 Parse an OPTIONS line and return values as a plist.
Optional argument BACKEND is an export back-end, as returned by,
e.g., `org-export-create-backend'. It specifies which back-end
specific items to read, if any.
(defalias 'org-export--parse-option-keyword #[(options &optional backend) "\306\205 \307! \"\310\n\310 \211 \203R
@\211@\311\f8 \203J \312 \"\204J \313\314\315!\316Q\"\203J \317 \320\321\311\"!@#*
A\211\204 * *\207" [backend org-export-options-alist all plist option --dolist-tail-- append org-export-get-all-options nil 2 plist-member string-match "\\(\\`\\|[ ]\\)" regexp-quote ":\\(([^)\n]+)\\|[^ \n
;,.]*\\)" plist-put read-from-string match-string item property options] 8 (#$ . 50128)])
#@209 Get export options in subtree at point.
Optional argument BACKEND is an export back-end, as returned by,
e.g., `org-export-create-backend'. It specifies back-end used
for export. Return options as a plist.
(defalias 'org-export--get-subtree-options #[(&optional backend) "\212\214~\210\306\211\307 \203 \310 \210\202 \311\312!\210\313`\314\"\206+ \315\n!\210\316\306 \317\f \"*\211\203a \320\321\322 \323\211 9\203@
\202Y
\211 :\204P
;\205X \324\202X
@9\205X
@) \236A)\"#\313`\325\"\211\203r \326 \"\244\327 \330\331\332 \205\201 \333 ! \"\"\210),\207" [plist prop org-complex-heading-regexp string num element nil org-at-heading-p org-up-heading-safe org-back-to-heading t org-entry-get "EXPORT_TITLE" looking-at 4 match-string-no-properties plist-put :title org-element-parse-secondary-string keyword plain-text "EXPORT_OPTIONS" org-export--parse-option-keyword ("TITLE") mapc #[(option) "@A@ \205\211 \235?\205\211 \306 P \307 \310`\f\") B\205\210 \311\n\"?\205\210 \312\n \235\203s \313\301\211 9\203L \202j \211 :\204_ ;\205i \314\202i @9\205i @)\236A)\"\202\204 \3158\316=\203\202 \317!\202\204 #\211**\207" [option keyword property seen subtree-prop case-fold-search "EXPORT_" t org-entry-get plist-member plist-put org-element-parse-secondary-string plain-text 4 split org-split-string value plist org-element-document-properties element org-element-object-restrictions] 8] append org-export-get-all-options org-element-object-restrictions backend seen org-export-options-alist] 8 (#$ . 50868)])
#@312 Return current buffer export options, as a plist.
Optional argument BACKEND, when non-nil, is an export back-end,
as returned by, e.g., `org-export-create-backend'. It specifies
which back-end specific options should also be read in the
process.
Assume buffer is in Org mode. Narrowing, if any, is ignored.
(defalias 'org-export--get-inbuffer-options #[(&optional backend) "\306\211\307\310 \205 \311 !\f\" \312\313\314\315\306\316\317
\"\"\244!\" \320 \321\211 \2050 C\306\" \306 \211 \203\273 @!\306 \211 \203\261 @ \322 \"\211 ;\203\247 \323 \324 \325\211 !9\203v !\202\224 !\211 !:\204\211 !;\205\223 \326\202\223 !@9\205\223 !@)\"\236A)\"\206\245 \327=\205\245 \330#) A\211 \204Q * A\211 \204> \306. \207" [plist get-options case-fold-search backend org-export-options-alist options nil t append org-export-get-all-options format "^[ ]*#\\+%s:" regexp-opt delq mapcar cadr #[(keyword) "\306 \306\211\2030 @\211A@\f\232\203) \n@ \307
\"\203$ \210\202(
B) A\211\204\n \306+\207" [properties options option --dolist-tail-- keyword #1=#:var nil memql] 4] #[(&optional files plist) "\212\214~\210eb\210\306\307\310#\203x\311 \211\211:\204\" ;\205* \312\202* @9\205* @)\313=\203t\314 ;\203A \315\316\n #\202G \317 A@\n\"*\320 ;\203Y \315\316\n #\202_ \317 A@\n\"*\211 \321\232\203\240 \322\323\324 !!!\211 0\235\204\234 \325\326! 1r1q\210\327\216\330
\331\"c\210\310 2\332 \210)3
0B4\"4+)\202s\f\333\232\203\264 \3344\335 5\"\"4\202s\f\336\232\203\335 \3344\337\340\341 \342\"\3174\337\"\" 6\3436! 7\3447!*D\"4\202s8\f!\307\211 9\203r9@\345\n:\2368 ;\3464\n\347;\350\"\203 \3174\n\"\204\324 !\202e\3174\n\"\351\324 !Q\202e\347;\352\"\2033\324\3174\n\"\353\324 !Q!\202e\347;\354\"\203H\340\3174\n\"\341 !\"\202e\355;\356\"\203T \202e\3574\n\"\204` \202e\3174\n\"#4)9A\2119\204\351 **)\202 4*\207" [regexp element property val key file re-search-forward nil t org-element-at-point plain-text keyword :key get-text-property 0 plist-get :value "SETUPFILE" expand-file-name org-remove-double-quotes org-trim generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#2=#:temp-buffer buffer-name kill-buffer] 2] org-file-contents noerror org-mode "OPTIONS" org-combine-plists org-export--parse-option-keyword "FILETAGS" :filetags append org-split-string ":" copy-sequence delete-dups 4 plist-put eql space " " newline "\n" split memql 't plist-member files #2# org-inhibit-startup get-options plist backend list res find-properties --dolist-tail-- options behavior] 9] plist-get plist-put org-element-parse-secondary-string keyword plain-text :title "" org-export-special-keywords regexp find-properties buffer-file-name org-element-document-properties --dolist-tail-- property value element org-element-object-restrictions] 9 (#$ . 52446)])
#@61 Return properties related to buffer attributes, as a plist.
(defalias 'org-export--get-buffer-attributes #[nil "\301\302 !\303\304\305\302 !F)\207" [visited-file buffer-file-name buffer-base-buffer :input-file :input-buffer buffer-name] 5 (#$ . 55327)])
#@244 Return global export options as a plist.
Optional argument BACKEND, if non-nil, is an export back-end, as
returned by, e.g., `org-export-create-backend'. It specifies
which back-end specific export options should also be read in the
process.
(defalias 'org-export--get-global-options #[(&optional backend) "\306\307\205 \310! \"\n\306 \211 \203\201
@\211@ \311 \"\204y \312 \313\314\f8!\211 ;\203t \fA@\235\203t \315\316\211 9\203M \202k \211 :\204` ;\205j \317\202j @9\205j @)\236A)\"\202v )#)
A\211\204 \306 ,\207" [backend org-export-options-alist all plist cell --dolist-tail-- nil append org-export-get-all-options plist-member plist-put eval 3 org-element-parse-secondary-string keyword plain-text prop value org-element-document-properties element org-element-object-restrictions] 8 (#$ . 55590)])
#@182 Return variables bound from BIND keywords in current buffer.
Also look for BIND keywords in setup files. The return value is
an alist where associations are (VARIABLE-NAME VALUE).
(defalias 'org-export--list-bound-variables #[nil "\205 \302\303\211\302\211\"\237*\207" [org-export-allow-bind-keywords collect-bind nil #[(files alist) "\306\212\214~\210eb\210\307\310\311\306#\203\252 \312 \211\211:\204$ ;\205, \313\202, @9\205, @)\314=\203\246 \315 ;\203C \316\317\n #\202I \320 A@\n\"*\321 ;\203\\ \316\317\n #\202b \320 A@\n\"*\322\232\203t \323\324\325 \"!\fB\202\245 \326\327 !!\211 \235\204\244 \330\331! r q\210\332\216\306 \333 \210)\334
\335\"c\210!
B\f\"+)))\202 \f+\207" [case-fold-search element property val alist file t re-search-forward "^[ ]*#\\+\\(BIND\\|SETUPFILE\\):" nil org-element-at-point plain-text keyword :value get-text-property 0 plist-get :key "BIND" read format "(%s)" expand-file-name org-remove-double-quotes generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1=#:temp-buffer buffer-name kill-buffer] 2] org-mode org-file-contents noerror files #1# org-inhibit-startup collect-bind] 5]] 4 (#$ . 56440)])
#@70 Return BLOB parent or nil.
BLOB is the element or object considered.
(defalias 'org-export-get-parent #[(blob) "\303 ;\203 \304\305\n #\202 \306 A@\n\"*\207" [blob element property :parent get-text-property 0 plist-get] 4 (#$ . 57624)])
(put 'org-export-get-parent 'byte-optimizer 'byte-compile-inline-expand)
#@817 Extract tree properties from parse tree.
DATA is the parse tree from which information is retrieved. INFO
is a list holding export options.
Following tree properties are set or updated:
`:exported-data' Hash table used to memoize results from
`org-export-data'.
`:footnote-definition-alist' List of footnotes definitions in
original buffer and current parse tree.
`:headline-offset' Offset between true level of headlines and
local level. An offset of -1 means a headline
of level 2 should be considered as a level
1 headline in the context.
`:headline-numbering' Alist of all headlines as key an the
associated numbering as value.
`:ignore-list' List of elements that should be ignored during
export.
Return updated plist.
(defalias 'org-export-collect-tree-properties #[(data info) "\303\304 #\303\305\306\307 \"\310\305\"\"#\303\311\312\313 \"Z#\310\314\"\315 \316\317#\210\303\314\n#)\320\321 \"\322\323\324\325\326\327$F\244\207" [info data defs plist-put :parse-tree :ignore-list append org-export--populate-ignore-list plist-get :headline-offset 1 org-export--get-min-level :footnote-definition-alist org-element-map footnote-definition #[(fn) "\304 ;\203 \305\306\n #\202 \307 A@\n\"*\310\311\211:\204% \311\2022 @9\2031 AA\2022 )BBB B\211\207" [fn element property defs :label get-text-property 0 plist-get org-data nil] 5] :headline-numbering org-export--collect-headline-numbering :exported-data make-hash-table :test eq :size 4001] 8 (#$ . 57946)])
#@159 Return minimum exportable headline's level in DATA.
DATA is parsed tree as returned by `org-element-parse-buffer'.
OPTIONS is a plist holding export options.
(defalias 'org-export--get-min-level #[(data options) "\30320 \304\305\306 \211:\204 \307\202 \n@9\203 \nAA\202 \n)\"\210\304U\203- \310\202. )0\207" [min-level data element exit 10000 mapc #[(blob) "\211:\204 ;\205 \305\202 @9\205 @)\306=\203] \307 ;\203/ \310\311\n #\2025 \312 A@\n\"*\204] \312 \313\">\204] \314 ;\203S \310\311\n #\202Y \312 A@\n\"*\f^\f\315U\205g \316\317\315\"\207" [blob element property options min-level plain-text headline :footnote-section-p get-text-property 0 plist-get :ignore-list :level 1 throw exit] 5] nil 1] 4 (#$ . 59532)])
#@281 Return numbering of all exportable headlines in a parse tree.
DATA is the parse tree. OPTIONS is the plist holding export
options.
Return an alist whose key is a headline and value is its
associated numbering (in the shape of a list of numbers) or nil
for a footnotes section.
(defalias 'org-export--collect-headline-numbering #[(data options) "\304\305\"\306\n\307\310 $)\207" [org-export-max-depth numbering data options make-vector 0 org-element-map headline #[(headline) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*?\205\216 \312 \"S
\313 \314 \310 \314 T\211
GW\203\210
HX\203\210 \fW\203` B\fU\203s
TIB\fV\203\200
\310I\210T\2026 \237.B\207" [headline element property options relative-level numbering :footnote-section-p get-text-property 0 plist-get org-export-get-relative-level -1 nil #1=#:--cl-vec-- #2=#:--cl-idx-- n idx org-export-max-depth #3=#:--cl-var-- #4=#:--cl-var--] 4]] 5 (#$ . 60283)])
#@144 Return list of elements and objects to ignore during export.
DATA is the parse tree to traverse. OPTIONS is the plist holding
export options.
(defalias 'org-export--populate-ignore-list #[(data options) "\305\211\306\n \" \307\211\n!\210,\207" [ignore walk-data data options selected nil org-export--selected-trees #[(data) "\211:\204 ;\205 \306\202 @9\205 @)\307 \f#\203*
B\211\202\300 \n\310=\203v \311 \312\"\310=\203v \313 ;\203L \314\315 #\202S \311 A@\"*\203v \316\317\211:\204d \320\202q @9\203p AA\202q )\"\202\300 \n\236A\211 \203\242 \316 ;\203\230 \314\315 #\202\237 \311 A@\"*\"\210)\316\211:\204\261 \320\202\276 @9\203\275 AA\202\276 )\")\207" [data element type options selected ignore plain-text org-export--skip-p headline plist-get :with-archived-trees :archivedp get-text-property 0 mapc #[(e) " B\211\207" [e ignore] 2] nil property org-element-secondary-value-alist sec-prop walk-data] 7]] 4 (#$ . 61264)])
#@178 Return list of headlines and inlinetasks with a select tag in their tree.
DATA is parsed data as returned by `org-element-parse-buffer'.
INFO is a plist holding export options.
(defalias 'org-export--selected-trees #[(data info) "\303\211\304\211\n\303\"\210+\207" [selected-trees walk-data data nil #[(data genealogy) "\211:\204 ;\205 \306\202 @9\205 @)\211\307>\203\246 \310 ;\2031 \311\312 #\2027 \313 A@ \"* \313
\314\" \315 \316 \315 :\203i @\211\f\235\211?\211\203i A\211\202J ,\203\200 \317 \320\321\322# #\211 \202\242 \n\323=\205\242 \324\325\211:\204\223 \315\202\240 @9\203\237 AA\202\240 )\")\202\317 \n\326=\204\263 \n >\205\317 \324\327\211:\204\300 \315\202\315 @9\203\314 AA\202\315 )\")\207" [data element type property tags info plain-text (headline inlinetask) :tags get-text-property 0 plist-get :select-tags nil t append org-element-map (headline inlinetask) identity headline mapc #[(el) " \n B\"\207" [walk-data el data genealogy] 4] org-data #[(el) " \n\"\207" [walk-data el genealogy] 3] #1=#:--cl-var-- tag #2=#:--cl-flag-- #3=#:--cl-var-- genealogy selected-trees org-element-greater-elements] 7]] 4 (#$ . 62255)])
#@217 Non-nil when element or object BLOB should be skipped during export.
OPTIONS is the plist holding export options. SELECTED, when
non-nil, is a list of headlines or inlinetasks belonging to
a tree with a select tag.
(defalias 'org-export--skip-p #[(blob options selected) "\211:\204 ;\205 \306\202 @9\205 @)\307\n\310\"\203) \311 \312\"?\202\237\307\n\313\"\203t \311 \314\"\211 ?\206p \f:\205p \315 ;\203P \316\317
#\202V \311 A@
\"* <\f@\320=\203i \321<\fA\"\202o \321<\f\"?))\202\237\322\n\323\"\203\203 \311 \324\"?\202\237\322\n\325\"\203\264\311 \326\"\327 ;\203\237 \316\317
#\202\245 \311 A@
\"*\330 ;\203\267 \316\317
#\202\275 \311 A@
\"*\311 \331\"\332 ;\203\323 \316\317
#\202\331 \311 A@
\"* = > ? @ A\211:\204\364 ;\205\374 \306\202\374 @9\205\374 @)\333=\203\n\311 \334\"?\206\260\311 \335\" B\336 C\337 D\336 EB:\203;B@\211C=\235\211E?\211D\203;BA\211B\202E,\206\260F\203NF>?\206\260\340 ;\203_\316\317
#\202e\311 A@
\"*\206\260>\204\211\341 ;\203\316\317
#\202\205\311 A@
\"*\206\260@\205\260A?\206\260A\342>\203\244?A=?\206\260A:\205\260@A\235?-\202\237\322\n\343\"\203\303\311 \344\"?\202\237\307\n\345\"\203\322\311 \346\"?\202\237\307\n\347\"\203\341\311 \350\"?\202\237\307\n\351\"\203\370\352\353!!\205\237\354 \"?\202\237\307\n\355\"\203\356 \"\202\237\307\n\357\"\205\237\360!\211 G\211:\204\" ;\205*\306\202* @9\205* @)\361>\205?\362G\306\363\357H\"B\364 \337%?)\205\237\311 \365\" I\322I\366\"\203U\337\202\236\307I\367\"\203{\370 ;\203n\316\317
#\202t\311 A@
\"*\371>?\202\236\307I\372\"\205\236\370 ;\203\224\316\317
#\202\232\311 A@
\"*\373>?))\207" [blob element #1=#:temp options with-drawers-p property plain-text eql clock plist-get :with-clocks drawer :with-drawers :drawer-name get-text-property 0 not member-ignore-case memql (footnote-definition footnote-reference) :with-footnotes (headline inlinetask) :with-tasks :todo-keyword :todo-type :with-archived-trees :tags inlinetask :with-inlinetasks :exclude-tags nil t :commentedp :archivedp (todo done) (latex-environment latex-fragment) :with-latex planning :with-planning statistics-cookie :with-statistics-cookies table-cell org-export-table-has-special-column-p org-export-get-parent-table org-export-get-previous-element table-row org-export-table-row-is-special-p timestamp org-export-get-parent-element (paragraph verse-block) org-element-map remq #[(obj) ";?\206 \301!\207" [obj org-string-nw-p] 2] :with-timestamps 'nil active :type (active active-range) inactive (inactive inactive-range) name tags archived todo-type todo with-tasks #2=#:--cl-var-- k #3=#:--cl-flag-- #4=#:--cl-var-- selected parent org-element-all-objects #5=#:temp] 9 (#$ . 63459)])
#@87 Return appropriate transcoder for BLOB.
INFO is a plist containing export directives.
(defalias 'org-export-transcoder #[(blob info) "\211:\204 ;\205 \305\202 @9\205 @)\211\306=\203$ \307\2024 \n\310 \311\"\236A \312\f!\2053 \f))\207" [blob element type info transcoder plain-text org-data #[(blob contents info) "\207" [contents] 1] plist-get :translate-alist functionp] 5 (#$ . 66253)])
#@173 Convert DATA into current back-end format.
DATA is a parse tree, an element or an object or a secondary
string. INFO is a plist holding export options.
Return a string.
(defalias 'org-export-data #[(data info) "\306\307 \310\"\"\206\211:\204 \n;\205\" \311\202\" \n@9\205\" \n@)\307 \312\">\2031 \313\202\255 \311=\203S \314\307 \315\"\316 \"\211 \203L \f \"\202M ) #\202\255\317 \"\204\200 \320\321\322\323\211:\204j \313\202w \n@9\203v \nAA\202w \n)\324#\" \"\202\255 \204\214 \322\325\324#\202\255\211:\204\227 \313\202\244 \n@9\203\243 \nAA\202\244 \n)\203\322 \326=\203\360 \307 \327\"\326=\203\360 \330 \n;\203\310 \331\332
\n#\202\316 \307\nA@
\"*\203\360 \316 \" \333\f!\203\345 \f\313 #\206\354 \334=\205\354 \324)\202\255\316 \"\211 \205\254 ,>\211 -?\205 .> /\322\335-\204/\203\202}\336 \337=\205| 0\3400 \n;\2037\331\332
\n#\202=\307\nA@
\"+\211 1\211:\204K\313\202X\n@9\203W\nAA\202X\n)@=\205{1\211:\204p\n;\205x\311\202x\n@9\205x\n@)\341>)\"\211:\204\207\313\202\224\n@9\203\223\nAA\202\224\n)\324# 2\f-\204\2452\202\251\3422! #+) 3\3433\204\272\324\202\f \344>\203\3053\202\f\314\307 \345\346\347 \"!\"\350 \n;\203\340\331\332
\n#\202\346\307\nA@
\"*\206\353\332 4 5>\203\3423!\3514\352\"P\202 3\3514\353\"P) #\307 \310\"#*\207" [data info element type transcoder property gethash plist-get :exported-data plain-text :ignore-list nil org-export-filter-apply-functions :filter-plain-text org-export-transcoder org-export--interpret-p org-export-data org-export-expand mapconcat #[(blob) "\302 \"\207" [blob info org-export-data] 3] "" #[(obj) "\302 \"\207" [obj info org-export-data] 3] headline :with-archived-trees :archivedp get-text-property 0 functionp export-snippet #[(element) "\302 \"\207" [element info org-export-data] 3] org-element-normalize-contents paragraph :parent (footnote-definition item) org-element-normalize-string puthash (org-data plain-text nil) intern format ":filter-%s" :post-blank make-string 10 32 org-element-greater-elements greaterp org-element-recursive-objects objectp blob parent contents results post-blank org-element-all-elements] 10 (#$ . 66660)])
#@285 Convert DATA into BACKEND format.
DATA is an element, an object, a secondary string or a string.
BACKEND is a symbol. INFO is a plist used as a communication
channel.
Unlike to `org-export-with-backend', this function will
recursively convert DATA using BACKEND translation table.
(defalias 'org-export-data-with-backend #[(data backend info) "9\203 \303!\304 \305\n\306\307\310!\311\312\313\314\315\316$\257\"\"\207" [backend data info org-export-get-backend org-export-data org-combine-plists :back-end :translate-alist org-export-get-all-transcoders :exported-data make-hash-table :test eq :size 401] 14 (#$ . 68870)])
#@184 Non-nil if element or object BLOB should be interpreted during export.
If nil, BLOB will appear as raw Org syntax. Check is done
according to export options INFO, stored as a plist.
(defalias 'org-export--interpret-p #[(blob info) "\211:\204 ;\205 \306\202 @9\205 @)\307\n\310\"\203( \311 \312\"\202\240 \313\n\314\"\2036 \311 \315\"\202\240 \307\n\316\"\203D \311 \317\"\202\240 \313\n\320\"\203\\ \311 \321\"\211 \205X \f\322=?)\202\240 \313\n\323\"\203\221 \311 \324\"\211 \325=\203\214 \326 ;\203\201 \327\330 #\202\210 \311 A@ \"*\202\215
)\202\240 \307\n\331\"\203\237 \311 \332\"\202\240 \333)\207" [blob element #1=#:temp info with-latex-p sub/super-p plain-text eql entity plist-get :with-entities memql (bold italic strike-through underline) :with-emphasize fixed-width :with-fixed-width (latex-environment latex-fragment) :with-latex verbatim (subscript superscript) :with-sub-superscript {} :use-brackets-p get-text-property 0 table :with-tables t property] 5 (#$ . 69509)])
#@237 Expand a parsed element or object to its original state.
BLOB is either an element or an object. CONTENTS is its
contents, as a string or nil.
When optional argument WITH-AFFILIATED is non-nil, add affiliated
keywords before output.
(defalias 'org-export-expand #[(blob contents &optional with-affiliated) "\211:\204 ;\205 \306\202 @9\205 @) \205' \n\f>\205' \307!\310\311\312\n\"!
\"P)\207" [blob element type with-affiliated org-element-all-elements contents plain-text org-element--interpret-affiliated-keywords intern format "org-element-%s-interpreter"] 6 (#$ . 70522)])
#@152 Add ELEMENT to `:ignore-list' in INFO.
Any element in `:ignore-list' will be skipped when using
`org-element-map'. INFO is modified by side effects.
(defalias 'org-export-ignore-element #[(element info) "\302\303 \304\303\"B#\207" [info element plist-put :ignore-list plist-get] 7 (#$ . 71120)])
#@380 Hook run at the beginning of the export process.
This is run before include keywords and macros are expanded and
Babel code blocks executed, on a copy of the original buffer
being exported. Visibility and narrowing are preserved. Point
is at the beginning of the buffer.
Every function in this hook will be called with one argument: the
back-end currently used, as a symbol.
(defvar org-export-before-processing-hook nil (#$ . 71427))
#@378 Hook run before parsing an export buffer.
This is run after include keywords and macros have been expanded
and Babel code blocks executed, on a copy of the original buffer
being exported. Visibility and narrowing are preserved. Point
is at the beginning of the buffer.
Every function in this hook will be called with one argument: the
back-end currently used, as a symbol.
(defvar org-export-before-parsing-hook nil (#$ . 71873))
#@214 List of functions applied to the export options.
Each filter is called with two arguments: the export options, as
a plist, and the back-end, as a symbol. It must return
a property list containing export options.
(defvar org-export-filter-options-functions nil (#$ . 72314))
#@274 List of functions applied to the parsed tree.
Each filter is called with three arguments: the parse tree, as
returned by `org-element-parse-buffer', the back-end, as
a symbol, and the communication channel, as a plist. It must
return the modified parse tree to transcode.
(defvar org-export-filter-parse-tree-functions nil (#$ . 72596))
#@228 List of functions applied to plain text.
Each filter is called with three arguments: a string which
contains no Org syntax, the back-end, as a symbol, and the
communication channel, as a plist. It must return a string or
nil.
(defvar org-export-filter-plain-text-functions nil (#$ . 72941))
#@266 List of functions applied to the transcoded string.
Each filter is called with three arguments: the full transcoded
string, the back-end, as a symbol, and the communication channel,
as a plist. It must return a string that will be used as the
final export output.
(defvar org-export-filter-final-output-functions nil (#$ . 73240))
#@236 List of functions applied to a transcoded babel-call.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-babel-call-functions nil (#$ . 73579))
#@238 List of functions applied to a transcoded center block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-center-block-functions nil (#$ . 73886))
#@231 List of functions applied to a transcoded clock.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-clock-functions nil (#$ . 74197))
#@233 List of functions applied to a transcoded comment.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-comment-functions nil (#$ . 74494))
#@239 List of functions applied to a transcoded comment-block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-comment-block-functions nil (#$ . 74795))
#@236 List of functions applied to a transcoded diary-sexp.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-diary-sexp-functions nil (#$ . 75108))
#@232 List of functions applied to a transcoded drawer.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-drawer-functions nil (#$ . 75415))
#@239 List of functions applied to a transcoded dynamic-block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-dynamic-block-functions nil (#$ . 75714))
#@239 List of functions applied to a transcoded example-block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-example-block-functions nil (#$ . 76027))
#@238 List of functions applied to a transcoded export-block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-export-block-functions nil (#$ . 76340))
#@237 List of functions applied to a transcoded fixed-width.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-fixed-width-functions nil (#$ . 76651))
#@245 List of functions applied to a transcoded footnote-definition.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-footnote-definition-functions nil (#$ . 76960))
#@234 List of functions applied to a transcoded headline.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-headline-functions nil (#$ . 77285))
#@241 List of functions applied to a transcoded horizontal-rule.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-horizontal-rule-functions nil (#$ . 77588))
#@236 List of functions applied to a transcoded inlinetask.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-inlinetask-functions nil (#$ . 77905))
#@230 List of functions applied to a transcoded item.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-item-functions nil (#$ . 78212))
#@233 List of functions applied to a transcoded keyword.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-keyword-functions nil (#$ . 78507))
#@243 List of functions applied to a transcoded latex-environment.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-latex-environment-functions nil (#$ . 78808))
#@239 List of functions applied to a transcoded node-property.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-node-property-functions nil (#$ . 79129))
#@235 List of functions applied to a transcoded paragraph.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-paragraph-functions nil (#$ . 79442))
#@236 List of functions applied to a transcoded plain-list.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-plain-list-functions nil (#$ . 79747))
#@234 List of functions applied to a transcoded planning.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-planning-functions nil (#$ . 80054))
#@241 List of functions applied to a transcoded property-drawer.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-property-drawer-functions nil (#$ . 80357))
#@243 List of functions applied to a transcoded quote block.
Each filter is called with three arguments: the transcoded quote
data, as a string, the back-end, as a symbol, and the
communication channel, as a plist. It must return a string or
nil.
(defvar org-export-filter-quote-block-functions nil (#$ . 80674))
#@239 List of functions applied to a transcoded quote-section.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-quote-section-functions nil (#$ . 80989))
#@233 List of functions applied to a transcoded section.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-section-functions nil (#$ . 81302))
#@239 List of functions applied to a transcoded special block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-special-block-functions nil (#$ . 81603))
#@235 List of functions applied to a transcoded src-block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-src-block-functions nil (#$ . 81916))
#@231 List of functions applied to a transcoded table.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-table-functions nil (#$ . 82221))
#@236 List of functions applied to a transcoded table-cell.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-table-cell-functions nil (#$ . 82518))
#@235 List of functions applied to a transcoded table-row.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-table-row-functions nil (#$ . 82825))
#@237 List of functions applied to a transcoded verse block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-verse-block-functions nil (#$ . 83130))
#@233 List of functions applied to transcoded bold text.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-bold-functions nil (#$ . 83439))
#@233 List of functions applied to transcoded code text.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-code-functions nil (#$ . 83737))
#@232 List of functions applied to a transcoded entity.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-entity-functions nil (#$ . 84035))
#@240 List of functions applied to a transcoded export-snippet.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-export-snippet-functions nil (#$ . 84334))
#@244 List of functions applied to a transcoded footnote-reference.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-footnote-reference-functions nil (#$ . 84649))
#@243 List of functions applied to a transcoded inline-babel-call.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-inline-babel-call-functions nil (#$ . 84972))
#@242 List of functions applied to a transcoded inline-src-block.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-inline-src-block-functions nil (#$ . 85293))
#@235 List of functions applied to transcoded italic text.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-italic-functions nil (#$ . 85612))
#@240 List of functions applied to a transcoded latex-fragment.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-latex-fragment-functions nil (#$ . 85914))
#@236 List of functions applied to a transcoded line-break.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-line-break-functions nil (#$ . 86229))
#@230 List of functions applied to a transcoded link.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-link-functions nil (#$ . 86536))
#@238 List of functions applied to a transcoded radio-target.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-radio-target-functions nil (#$ . 86831))
#@243 List of functions applied to a transcoded statistics-cookie.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-statistics-cookie-functions nil (#$ . 87142))
#@243 List of functions applied to transcoded strike-through text.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-strike-through-functions nil (#$ . 87463))
#@235 List of functions applied to a transcoded subscript.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-subscript-functions nil (#$ . 87781))
#@237 List of functions applied to a transcoded superscript.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-superscript-functions nil (#$ . 88086))
#@232 List of functions applied to a transcoded target.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-target-functions nil (#$ . 88395))
#@235 List of functions applied to a transcoded timestamp.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-timestamp-functions nil (#$ . 88694))
#@238 List of functions applied to transcoded underline text.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-underline-functions nil (#$ . 88999))
#@237 List of functions applied to transcoded verbatim text.
Each filter is called with three arguments: the transcoded data,
as a string, the back-end, as a symbol, and the communication
channel, as a plist. It must return a string or nil.
(defvar org-export-filter-verbatim-functions nil (#$ . 89307))
#@345 Call every function in FILTERS.
Functions are called with arguments VALUE, current export
back-end's name and INFO. A function returning a nil value will
be skipped. If it returns the empty string, the process ends and
VALUE is ignored.
Call is done in a LIFO fashion, to be sure that developer
specified filters, if any, are called first.
(defalias 'org-export-filter-apply-functions #[(filters value info) "\3062b \307\310\"\211\205 \311H\n>\204 \312\313\314 D\"\210 \315H\f\316 \211 \203\\ @\211 #\211 \204? \210\202R \317\232\203N \320\306\316\"\210\202R )A\211\204) \316,0\207" [info backend cl-struct-org-export-backend-tags backend-name filters filter exit plist-get :back-end 0 signal wrong-type-argument org-export-backend 1 nil "" throw --dolist-tail-- value result] 5 (#$ . 89613)])
#@158 Install filters properties in communication channel.
INFO is a plist containing the current communication channel.
Return the updated communication channel.
(defalias 'org-export-install-filters #[(info) "\303\304\305 \"\210\304\306\307\310\n\311\"!\"\210\312\n\")\207" [plist org-export-filters-alist info nil mapc #[(p) "@\306\n \"AJ \307
\310 <\203 \202 C\f\"#\211+\207" [p prop info info-value default-value plist plist-get plist-put append] 6] #[(p) "@A \205% \304 \n :\204 \305 \n\"B\202\" \306 \305 \n\"\"#\211*\207" [p value key plist plist-put plist-get append] 8] org-export-get-all-filters plist-get :back-end org-combine-plists] 6 (#$ . 90447)])
#@111 Return a copy of the current buffer.
The copy preserves Org buffer-local variables, visibility and
narrowing.
(defalias 'org-export-copy-buffer #[nil "\302p!\303\304 !rq\210 \210\305\306!\210)*\207" [new-buf copy-buffer-fun org-export--generate-copy-script generate-new-buffer buffer-name set-buffer-modified-p nil] 3 (#$ . 91131)])
#@192 Apply BODY in a copy of the current buffer.
The copy preserves local variables, visibility and contents of
the original buffer. Point is at the beginning of the buffer
when BODY is applied.
(defalias 'org-export-with-buffer-copy '(macro . #[(&rest body) "\302\303!\304\305BC\306\307\310\311 BF\312\313D\311\307\314BB\315DEEEE)\207" [buf-copy body make-symbol "--buf-copy" let ((org-export-copy-buffer)) unwind-protect with-current-buffer (goto-char (point-min)) progn and buffer-live-p ((restore-buffer-modified-p nil)) kill-buffer] 10 (#$ . 91476)]))
(put 'org-export-with-buffer-copy 'edebug-form-spec t)
#@409 Generate a function duplicating BUFFER.
The copy will preserve local variables, visibility, contents and
narrowing of the original buffer. If a region was active in
BUFFER, contents will be narrowed to that region instead.
The resulting function can be evaluated at a later time, from
another buffer, effectively cloning the original buffer there.
The function assumes BUFFER's major mode is `org-mode'.
(defalias 'org-export--generate-copy-script #[(buffer) "rq\210\306\307\310\311\312\313\314 \307\315\316 !\307\211 \203t \f@\211:\203m @ A \211 %\317=\204l %\320>\204G %\n\236\204G \321\322\323%!\"\203l
\203^ \3241Y \325\326\327
\"!0\202[ \210\307\203l \330\331\332%DD\332
DE B*\fA\211\204 \307 ,\333\212\214~\210\334ed\"*D\335 \203\221 \336\337 \340 E\202\225 \336edE\341`DE\307 &\342\343\344ed\"\"\210&)#BBBE)\207" [buffer vars bound-variables entry --dolist-tail-- val lambda nil let ((inhibit-modification-hooks t)) (let ((org-mode-hook nil) (org-inhibit-startup t)) (org-mode)) append org-export--list-bound-variables buffer-local-variables buffer-base-buffer org-font-lock-keywords (default-directory buffer-file-name buffer-file-coding-system) string-match "^\\(org-\\|orgtbl-\\)" symbol-name (error) read format "%S" set make-local-variable quote insert buffer-substring-no-properties org-region-active-p narrow-to-region region-beginning region-end goto-char mapc #[(ov) "\303\304\"\211\205 \305\306\307!\310!E\311\312 DF\nB\211)\207" [ov invis-prop ov-set overlay-get invisible overlay-put make-overlay overlay-start overlay-end 'invisible quote] 6] overlays-in var ov-set] 14 (#$ . 92097)])
#@833 Transcode current Org buffer into BACKEND code.
BACKEND is either an export back-end, as returned by, e.g.,
`org-export-create-backend', or a symbol referring to
a registered back-end.
If narrowing is active in the current buffer, only transcode its
narrowed part.
If a region is active, transcode that region.
When optional argument SUBTREEP is non-nil, transcode the
sub-tree at point, extracting information from the headline
properties first.
When optional argument VISIBLE-ONLY is non-nil, don't export
contents of hidden elements.
When optional argument BODY-ONLY is non-nil, only return body
code, without surrounding template.
Optional argument EXT-PLIST, when provided, is a property list
with external parameters overriding Org default settings, but
still inferior to file-local settings.
Return code as a string.
(defalias 'org-export-as #[(backend &optional subtreep visible-only body-only ext-plist) "9\203 \306!\307!\210\212\214\310 \203 \311 \312 }\210\202. \203. \313 \210eb\210\314y\210`d}\210\315H\n>\204= \316\317\320D\"\210\321H\322\323\324\314 \205J \325\f\205O \304
\205T \305E\"D\326 \" @\314 A\327 B\330\216rBq\210eb\210\331\332\315H\n>\204~ \316\317\320D\"\210\321H\"\210\333 \210\334 \210\335C!\210\336 \210\337 \210eb\210\212\331\340\315H\n>\204\251 \316\317\320D\"\210\321H\"\210)\341\322@\342 D#\"!@\343@\344\"\204\345 \345@\344\343@\346\"\211 E\203\335 \347\350E!!\202\342 \343@\351\")#\210\335\352\353\343@\354\"!B\355\353\343@\356\"!B\357\343@\360\"\206\361B\362\353\343@\344\"!BF!\210\315H\n>\204 \316\317\320D\"\210\321H F\343@\363\"\314 G\211 H\203PH@\211G@F\"\211 I\203FI@)HA\211H\2041+\364\343@\365\"\366\314\f\"@#A\322@\367A@\"\"@\370\371A@\"\206w\361! J\372\343@\373\"\236A :\374:!\204\220J\202\227:J@\" K\375\343@\373\"\236A =\364\343@\376\"\374=!\203\264
\203\271K\202\300=K@\"@#\314 L M\377\201O !\203\337\201O \315MG\314M$\210\202 L\203\364\201P \315MGNM$\210\202 \201O \315MG\314M$\210M.\207" [backend subtreep cl-struct-org-export-backend-tags org-export-current-backend visible-only body-only org-export-get-backend org-export-barf-if-invalid-backend org-region-active-p region-beginning region-end org-narrow-to-subtree nil 0 signal wrong-type-argument org-export-backend 1 org-combine-plists :export-options delq subtree org-export--get-buffer-attributes org-export-copy-buffer #[nil "\301!\205 rq\210\302\303!\210)\304!\207" [#1=#:--buf-copy buffer-live-p restore-buffer-modified-p nil kill-buffer] 2] run-hook-with-args org-export-before-processing-hook org-export-expand-include-keyword org-macro-initialize-templates org-macro-replace-all org-export-execute-babel-code org-update-radio-target-regexp org-export-before-parsing-hook org-export-install-filters org-export-get-environment plist-get :title plist-put :input-file file-name-sans-extension file-name-nondirectory :input-buffer "author" org-element-interpret-data :author "date" :date "email" :email "" "title" :filter-options org-export-filter-apply-functions :filter-parse-tree org-element-parse-buffer org-export-collect-tree-properties org-element-normalize-string org-export-data inner-template :translate-alist functionp template :filter-final-output fboundp info tree #1# org-macro-templates ext-plist file backend-name filter --dolist-tail-- result body full-body restricted s org-rm-props set-text-properties remove-text-properties] 10 (#$ . 93735)])
#@467 Transcode STRING into BACKEND code.
BACKEND is either an export back-end, as returned by, e.g.,
`org-export-create-backend', or a symbol referring to
a registered back-end.
When optional argument BODY-ONLY is non-nil, only return body
code, without preamble nor postamble.
Optional argument EXT-PLIST, when provided, is a property list
with external parameters overriding Org default settings, but
still inferior to file-local settings.
Return code as a string.
(defalias 'org-export-string-as #[(string backend &optional body-only ext-plist) "\306\307!rq\210\310\216 c\210\311\312 \210)\313 \314\211\f
%+\207" [#1=#:temp-buffer string org-inhibit-startup backend body-only ext-plist generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1# buffer-name kill-buffer] 2] t org-mode org-export-as nil] 6 (#$ . 97218)])
#@190 Replace the active region by its export to BACKEND.
BACKEND is either an export back-end, as returned by, e.g.,
`org-export-create-backend', or a symbol referring to
a registered back-end.
(defalias 'org-export-replace-region-by #[(backend) "\305 \204 \306\307!\207\310 \311 {\312\313\n\f\314# |\210 c,\207" [beg end str rpl backend org-region-active-p user-error "No active region to replace" region-beginning region-end nil org-export-string-as t] 4 (#$ . 98057)])
#@417 Insert all export keywords with default values at beginning of line.
BACKEND is a symbol referring to the name of a registered export
back-end, for which specific export options should be added to
the template, or `default' for default template. When it is nil,
the user will be prompted for a category.
If SUBTREEP is non-nil, export configuration will be set up
locally for the subtree through node properties.
(defalias 'org-export-insert-default-template #[(&optional backend subtreep) "\306\307!\204\n \310\311!\210\203 \312 \203 \310\313!\210\205\" \212\314\315!\210`) \2061 \316\317\320\321\322\323\n\"B\"!\324\211 \325=\203B @\202\211 \326 !\203n G\327Y\203n \330HA>\203n \330HA>\204h \331\332\333 D\"\210 \334H\202\211 \335 !\211 B\330HA>\204\204 \331\332\333BD\"\210B\334H)\324 C\211 D\203\373 D@\211CA@\336C8 E\211 F\203\330 \337F \"\204\361 \334C8\340=\203\304 \341\342\343\344C8!\345#\202\312 \343\344C8! GFGB B)\202\361 E\203\361 \337E\f\"\204\361 E\343\344C8!B\fB*DA\211D\204\222 *\204\346 \210\337\347 \"\203:\350\351 !\211 H\205\352\353H!!)\206\"\354\351 ! I\2042\355\356I\"c\210\2029\357
\360I#\210)\337\361 \"\203j\362\363! JrJq\210\364\216\365\366 !+ K\204b\367K\370\261\210\202i\357
\371K#\210)\337\372 \"\203\233\337\372 \"A L\203\206\357
\373L#\210\202\232\355\374\375L!\204\223\376\202\227\345LP\"c\210)\337\377 \"\203\320\337\377 \"A M\203\271\357
\201T M#\210\202\317\355\201U \375M!\204\310\376\202\314\345MP\"c\210)\f\203B\322\201V \201W \f\201X \"\" N\203\367\357
\201Y \341\342N\345##\210\202AN\203A\201Z c\210\201[ ON\203:\201\\ ON@G\201] #PW\203:N\211AN\242 Q\345Q\261\210OQGT\\O)\202)\370c\210\202\367)\201W \201^ \"\324 R\211 D\205\241D@\211R@\201_ \235\204\227RA S\203z\357
\201` R@PS#\210\202\226\355\201a R@\375S!\203\222\355\201b S\"\202\223\376#c\210)DA\211D\204S\324.\207" [subtreep backend org-export--registered-backends keywords options node derived-mode-p org-mode user-error "Not in an Org mode buffer" org-before-first-heading-p "No subtree to set export options for" org-back-to-heading t intern org-completing-read "Options category: " "default" mapcar #[(b) "\302\303H >\204 \304\305\306D\"\210\307H!\207" [b cl-struct-org-export-backend-tags symbol-name 0 signal wrong-type-argument org-export-backend 1] 5] nil default vectorp 8 0 signal wrong-type-argument org-export-backend 4 org-export-get-backend 2 assoc split mapconcat identity eval 3 " " beginning-of-line "TITLE" buffer-file-name buffer-base-buffer file-name-sans-extension file-name-nondirectory buffer-name format "#+TITLE: %s\n" org-entry-put "EXPORT_TITLE" "DATE" generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1=#:temp-buffer buffer-name kill-buffer] 2] org-insert-time-stamp current-time "#+DATE: " "\n" "EXPORT_DATE" "AUTHOR" "EXPORT_AUTHOR" "#+AUTHOR:%s\n" org-string-nw-p "" "EMAIL" org-export-options-alist cl-struct-org-export-backend-tags cl-x entry --dolist-tail-- option keyword value visited-file title #1# date author email items width fill-column item key val "EXPORT_EMAIL" "#+EMAIL:%s\n" #[(opt) "\301\302@A#\207" [opt format "%s:%S"] 4] sort #[(k1 k2) "@ @\231\207" [k1 k2] 2] "EXPORT_OPTIONS" "#+OPTIONS:" 10 + 1 #[(k1 k2) "@ @\231\207" [k1 k2] 2] ("TITLE" "DATE" "AUTHOR" "EMAIL") "EXPORT_" "#+%s:%s\n" " %s"] 9 (#$ . 98540) nil])
#@300 Expand every include keyword in buffer.
Optional argument INCLUDED is a list of included file names along
with their line restriction, when appropriate. It is used to
avoid infinite recursion. Optional argument DIR is the current
working directory. It is used to properly resolve relative
paths.
(defalias 'org-export-expand-include-keyword #[(&optional included dir) "\306eb\210\307\310\311\306#\205~\312 \313\216\314 *\211\211:\204& \n;\205. \315\202. \n@9\205. \n@)\316=\203z\317 \210\320\n\n;\203H \321\322 \n#\202N \323\nA@ \"* \324 \325\326\f\"\205k \327\330\331\332\f\"!7\"\333\334\311\211\f$ 8\325\335\f\"\205 \331\332\f\"\333\334\311\211\f$ 9\325\336\f\"\203\214 \337\202\227 \325\340\f\"\205\227 \331\332\f\"\211 :?\205\307 \325\341\f\"\203\265 \342\331\332\f\"!\333\334\311\211\f$\202\307 \343 \211 ;\203\305 \344;!T\202\306 \332) <`\311y\210`|\2108\203x\3458!\204\345 \346\3478\"\210\202x89D=\235\203\371 \346\3508\"\210\202x:\337=\203 \351
\352\"\353\35489\"! > ?\355\356?>?$*c\210\202x:;\203F\351
\352\"\353\35489\"! > ?\355\357?:>?%*c\210\202x\360\361! @r@q\210\362\216\306 A\363 \210)\35489
<$c\210\36489D=B\3658!\"\210\366 +c\210.)\202 )\207" [case-fold-search save-match-data-internal element property value ind t re-search-forward "^[ ]*#\\+INCLUDE:" nil match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] org-element-at-point plain-text keyword beginning-of-line :value get-text-property 0 plist-get org-get-indentation string-match "^\\(\".+?\"\\|\\S-+\\)\\(?:\\s-+\\|$\\)" expand-file-name org-remove-double-quotes match-string 1 replace-match "" ":lines +\"\\(\\(?:[0-9]+\\)?-\\(?:[0-9]+\\)?\\)\"" "\\<example\\>" example "\\<src\\(?: +\\(.*\\)\\)?" ":minlevel +\\([0-9]+\\)" string-to-number org-current-level org-reduced-level file-readable-p error "Cannot include file %s" "Recursive file inclusion: %s" make-string 32 org-escape-code-in-string org-export--prepare-file-contents format "%s#+BEGIN_EXAMPLE\n%s%s#+END_EXAMPLE\n" "%s#+BEGIN_SRC %s\n%s%s#+END_SRC\n" generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1=#:temp-buffer buffer-name kill-buffer] 2] org-mode org-export-expand-include-keyword file-name-directory buffer-string dir file lines env cur minlevel included contents ind-str #1# org-inhibit-startup] 7 (#$ . 101954)])
#@588 Prepare the contents of FILE for inclusion and return them as a string.
When optional argument LINES is a string specifying a range of
lines, include only those lines.
Optional argument IND, when non-nil, is an integer specifying the
global indentation of returned contents. Since its purpose is to
allow an included file to stay in the same environment it was
created (i.e., a list item), it doesn't apply past the first
headline encountered.
Optional argument MINLEVEL, when non-nil, is an integer
specifying the level that any top-level headline in the included
file should have.
(defalias 'org-export--prepare-file-contents #[(file &optional lines ind minlevel) "\306\307!rq\210\310\216\311 !\210\n\203O \312\n\313\"\314\n@!\314\nA@! \315U\203, e\2024 eb\210 Sy\210` \f\315U\203? d\202G eb\210\fSy\210` $
$}\210-eb\210\316 \210\317 \210e`|\210db\210\320\321x\210\321y\210`d|\210%\203\307 &\322=\204} \323 '\322 \210)eb\210\324%\325\" (m\204\306 \326)!\204\306 \326*!\203\274 \327 \211 +:\204\254 +;\205\266 \330\202\266 +@9\205\266 +@)\331=\204\300 (c\210\321y\210\202\207 ),\203&\322=\204\332 \323 '\322 \210)\323 -\332 \211 . /\333.P )\334\335!\211 0\203,\336\3370\"Z\211 1\315U\2042\2031\340_1\334\341!\210)-\342\343 !+\207" [#1=#:temp-buffer file lines lbeg lend beg generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1# buffer-name kill-buffer] 2] insert-file-contents split-string "-" string-to-number 0 org-skip-whitespace beginning-of-line "
\n" nil org-mode t make-string 32 looking-at org-element-at-point plain-text footnote-definition org-get-limited-outline-regexp "^" org-map-entries #[nil "\300\301 !\207" [org-reduced-level org-current-level] 2] apply min 2 #[nil "\301W\203\f \302\303!!\207\304\305\"c\207" [offset 0 delete-char abs make-string 42] 3] org-element-normalize-string buffer-string end ind major-mode org-inhibit-startup ind-str org-outline-regexp-bol org-footnote-definition-re element minlevel org-called-with-limited-levels org-outline-regexp outline-regexp levels offset org-odd-levels-only] 5 (#$ . 104330)])
#@65 Execute every Babel code in the visible part of current buffer.
(defalias 'org-export-execute-babel-code #[nil "\302 \303\216\304 +\207" [reference org-current-export-file org-export-copy-buffer #[nil "\301!\207" [reference kill-buffer] 2] org-babel-exp-process-buffer] 1 (#$ . 106436)])
#@111 Return a non-nil value when output should be added to the kill ring.
See also `org-export-copy-to-kill-ring'.
(defalias 'org-export--copy-to-kill-ring-p #[nil "\303=\203
\206 \n?\207\304=\207" [org-export-copy-to-kill-ring executing-kbd-macro noninteractive if-interactive t] 2 (#$ . 106735)])
#@486 Turn ATTRIBUTE property from ELEMENT into a plist.
When optional argument PROPERTY is non-nil, return the value of
that property within attributes.
This function assumes attributes are defined as ":keyword
value" pairs. It is appropriate for `:attr_html' like
properties.
All values will become strings except the empty string and
"nil", which will become nil. Also, values containing only
double quotes will be read as-is, which means that "" value
will become the empty string.
(defalias 'org-export-read-attribute #[(attribute element &optional property) "\306 \n\n;\203 \307\310 \n#\202 \311\nA@ \"*\211 \205\\ \312\313\f\314#\315 \316\317\"\203S \310\211\224O \f!
B)\320\321\322\"!
B\310\225\315O\202( !
B\237A*) \203k \311 \"\202m *\207" [prepare-value attribute element property value result #[(str) "\302 \303\216 \304\235\203 \305\202\" \306\307 \"\203! \310\311 \"\206\" \312\202\" *\207" [save-match-data-internal str match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] (nil #1="" "nil") nil string-match "^\"\\(\"+\\)?\"$" match-string 1 #1#] 3] get-text-property 0 plist-get mapconcat identity " " nil string-match "\\(?:^\\|[ ]+\\)\\(:[-a-zA-Z0-9_]+\\)\\([ ]+\\|$\\)" intern match-string 1 s attributes] 5 (#$ . 107041)])
#@196 Return caption from ELEMENT as a secondary string.
When optional argument SHORTP is non-nil, return short caption,
as a secondary string, instead.
Caption lines are separated by a white space.
(defalias 'org-export-get-caption #[(element &optional shortp) "\306;\203 \307\310 #\202 \311A@ \"*\312\211\312 \211 \203J
@\203/ \313\2020 \314\f!\211 \203B \315C\316!\244\n\244)
A\211\204# \312\nA,\207" [element property caption full-caption line --dolist-tail-- :caption get-text-property 0 plist-get nil cdr car " " copy-sequence shortp cap] 5 (#$ . 108361)])
#@393 Call a transcoder from BACKEND on DATA.
BACKEND is an export back-end, as returned by, e.g.,
`org-export-create-backend', or a symbol referring to
a registered back-end. DATA is an Org element, object, secondary
string or string. CONTENTS, when non-nil, is the transcoded
contents of DATA element, as a string. INFO, when non-nil, is
the communication channel used for export, as a plist.
(defalias 'org-export-with-backend #[(backend data &optional contents info) "9\203 \306!\307!\210 \211:\204 \n;\205% \310\202% \n@9\205% \n@)\211\311>\2033 \312\313!\202_ \314! \f\236A \315
!\204H \312\313!\202^
\316\317\320\f\321\322\323\324\325\326$\257\"#*)\207" [backend data element type all-transcoders transcoder org-export-get-backend org-export-barf-if-invalid-backend plain-text (nil org-data) error "No foreign transcoder available" org-export-get-all-transcoders functionp org-combine-plists :back-end :translate-alist :exported-data make-hash-table :test eq :size 401 contents info] 16 (#$ . 108947)])
#@124 Return EXPORT-SNIPPET targeted back-end as a symbol.
Translation, with `org-export-snippet-translation-alist', is
applied.
(defalias 'org-export-snippet-backend #[(export-snippet) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311\312 \f\"A\206# !)\207" [export-snippet element property back-end org-export-snippet-translation-alist :back-end get-text-property 0 plist-get intern assoc] 4 (#$ . 109979)])
#@347 Return an alist between footnote numbers, labels and definitions.
DATA is the parse tree from which definitions are collected.
INFO is the plist used as a communication channel.
Definitions are sorted by order of references. They either
appear as Org data or as a secondary string for inlined
footnotes. Unreferenced definitions are ignored.
(defalias 'org-export-collect-footnote-definitions #[(data info) "\303\211\304\211\305\n\306\"!\210\307!+\207" [num-alist collect-fn info nil #[(data) "\302\303\304 \305\306&\207" [data info org-element-map footnote-reference #[(fn) "\306 \"\205O \307 \"\310 \"\311 ;\203! \312\313\f #\202' \314 A@\f\"*\nE
B\315 ;\203> \312\313\f #\202D \314 A@\f\"*\316=\205N \n!)\207" [fn info def element property num-alist org-export-footnote-first-reference-p org-export-get-footnote-definition org-export-get-footnote-number :label get-text-property 0 plist-get :type standard collect-fn] 5] nil footnote-definition] 7] plist-get :parse-tree reverse] 5 (#$ . 110393)])
#@182 Non-nil when a footnote reference is the first one for its label.
FOOTNOTE-REFERENCE is the footnote reference being considered.
INFO is the plist used as a communication channel.
(defalias 'org-export-footnote-first-reference-p #[(footnote-reference info) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\211\204! \312\2023 \313 \314 \31520 \f\311
\316\"!0*=)\207" [footnote-reference element property label search-refs info :label get-text-property 0 plist-get t nil #[(data) "\302\303\304 \305\306&\207" [data info org-element-map footnote-reference #[(fn) "\306 ;\203 \307\310\n #\202 \311 A@\n\"* \230\203\" \312\313\"\207\314 ;\2033 \307\310\n #\2029 \311 A@\n\"*\315=\205E \f\316
\"!\207" [fn element property label search-refs info :label get-text-property 0 plist-get throw exit :type standard org-export-get-footnote-definition] 4] first-match footnote-definition] 7] exit :parse-tree] 5 (#$ . 111424)])
#@187 Return definition of FOOTNOTE-REFERENCE as parsed data.
INFO is the plist used as a communication channel. If no such
definition can be found, return the "DEFINITION NOT FOUND"
string.
(defalias 'org-export-get-footnote-definition #[(footnote-reference info) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311 ;\203* \306\307\n #\2020 \310 A@\n\"*\206@ \312 \310\f\313\"\"A\206@ \314)\207" [footnote-reference element property label info :label get-text-property 0 plist-get :inline-definition assoc :footnote-definition-alist "DEFINITION NOT FOUND."] 5 (#$ . 112358)])
#@159 Return number associated to a footnote.
FOOTNOTE is either a footnote reference or a footnote definition.
INFO is the plist used as a communication channel.
(defalias 'org-export-get-footnote-number #[(footnote info) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\312\211 \313 \3142+
\311\315\"!0,\207" [footnote element property label seen-refs search-ref :label get-text-property 0 plist-get nil #[(data) "\302\303\304 \305\306&\207" [data info org-element-map footnote-reference #[(fn) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\211\204, \f=\203, \312\313
GT\"\202b \203A \230\203A \312\313
GT\"\202b \204M \314
B\315\202b
\235?\205b
B\316\"!\210\315)\207" [fn element property fn-lbl footnote seen-refs :label get-text-property 0 plist-get throw exit inline nil org-export-get-footnote-definition label search-ref info] 5] first-match footnote-definition] 7] exit :parse-tree info] 5 (#$ . 112940)])
#@108 Return HEADLINE relative level within current parsed tree.
INFO is a plist holding contextual information.
(defalias 'org-export-get-relative-level #[(headline info) "\304 ;\203 \305\306\n #\202 \307 A@\n\"*\307 \310\"\206 \306\\\207" [headline element property info :level get-text-property 0 plist-get :headline-offset] 4 (#$ . 113882)])
#@317 Non-nil when HEADLINE is considered as low level.
INFO is a plist used as a communication channel.
A low level headlines has a relative level greater than
`:headline-levels' property value.
Return value is the difference between HEADLINE relative level
and the last level being considered as high enough, or nil.
(defalias 'org-export-low-level-p #[(headline info) "\304\305\"\306 !\205 \307\n\"\211 V\205 Z))\207" [info limit headline level plist-get :headline-levels wholenump org-export-get-relative-level] 4 (#$ . 114235)])
#@97 Return HEADLINE numbering as a list of numbers.
INFO is a plist holding contextual information.
(defalias 'org-export-get-headline-number #[(headline info) "\302\303 \304\"\"A\207" [headline info assoc plist-get :headline-numbering] 5 (#$ . 114780)])
#@113 Return a non-nil value if HEADLINE element should be numbered.
INFO is a plist used as a communication channel.
(defalias 'org-export-numbered-headline-p #[(headline info) "\304\305\"\306 \"\307 !\203 \n X\202 *\207" [info headline level sec-num plist-get :section-numbers org-export-get-relative-level wholenump] 4 (#$ . 115039)])
#@41 Convert integer N into a roman numeral.
(defalias 'org-export-number-to-roman #[(n) "\303\304\n\305X\203 \306\n!\2024 \2033 \n @@Y\203+ \n @@Z @AP\202 \211A\210\202 *\207" [res roman n ((1000 . "M") (900 . "CM") (500 . "D") (400 . "CD") (100 . "C") (90 . "XC") (50 . "L") (40 . "XL") (10 . "X") (9 . "IX") (5 . "V") (4 . "IV") (1 . "I")) "" 0 number-to-string] 2 (#$ . 115384)])
#@511 Return list of tags associated to ELEMENT.
ELEMENT has either an `headline' or an `inlinetask' type. INFO
is a plist used as a communication channel.
Select tags (see `org-export-select-tags') and exclude tags (see
`org-export-exclude-tags') are removed from the list.
When non-nil, optional argument TAGS should be a list of strings.
Any tag belonging to this list will also be removed.
When optional argument INHERITED is non-nil, tags can also be
inherited from parent headlines and FILETAGS keywords.
(defalias 'org-export-get-tags #[(element info &optional tags inherited) "\306\307\204! \310 ;\203 \311\312\n #\202 \313 A@\n\"*\202S \310 ;\2032 \311\312\n #\2028 \313 A@\n\"*\314\315\316 !\"\210\317\313\f\320\" \" \321
! \322!+\"\207" [inherited element property current-tag-list info list org-remove-if #[(tag) "\303 \304\"\235\206 \303 \305\"\235\206 \n\235\207" [tag info tags plist-get :select-tags :exclude-tags] 4] :tags get-text-property 0 plist-get mapc #[(parent) "\303\304\305 ;\203 \306\307\n #\202 \310 A@\n\"*\"\207" [parent element property mapc #[(tag) "\211:\204 ;\205 \304\202 @9\205 @)\305>\205* \n \235?\205* \n B\211\207" [parent element tag current-tag-list plain-text (headline inlinetask)] 3] :tags get-text-property 0 plist-get] 6] org-export-get-genealogy append :filetags copy-sequence delete-dups res] 6 (#$ . 115782)])
#@251 Return node PROPERTY value for BLOB.
PROPERTY is an upcase symbol (i.e. `:COOKIE_DATA'). BLOB is an
element or object.
If optional argument INHERITED is non-nil, the value can be
inherited from a parent headline.
Return value is a string or nil.
(defalias 'org-export-get-node-property #[(property blob &optional inherited) "\211:\204 ;\205 \306\202 @9\205 @)\302=\203\" \202% \307! \204E \f ;\203; \310\311\f #\202A \312 A@\f\"*\202\234 \n\313 \3142\233 \205\232 \315A@\f\"\203z \316\314\f ;\203q \310\311\f #\202w \312 A@\f\"*\"\210\317 ;\203\214 \310\311\f #\202\222 \312 A@\f\"*\211\204S \3130*)\207" [blob element headline inherited property value plain-text org-export-get-parent-headline get-text-property 0 plist-get nil found plist-member throw :parent parent] 7 (#$ . 117181)])
#@263 Return category for element or object BLOB.
INFO is a plist used as a communication channel.
CATEGORY is automatically inherited from a parent headline, from
#+CATEGORY: keyword or created out of original file name. If all
fail, the fall-back value is "???".
(defalias 'org-export-get-category #[(blob info) "\211:\204 ;\205 \306\202 @9\205 @)\302=\203\" \202% \307!\211\310 \3112} \f\205| \312\f ;\203C \313\314
#\202I \315 A@
\"*\211 \203] \316\232\204] \317\311\"\210)\320\f ;\203o \313\314
#\202u \315 A@
\"*\211\2042 \3100+\206\246 \321\315\322\"\323\324\325%\206\246 \315\326\"\211 \205\241 \327\330!!)\206\246 \316\207" [blob element headline value parent property plain-text org-export-get-parent-headline nil found :CATEGORY get-text-property 0 plist-get "???" throw :parent org-element-map :parse-tree keyword #[(kwd) "\303 ;\203 \304\305\n #\202 \306 A@\n\"*\307\232\2055 \310 ;\203. \304\305\n #\2024 \306 A@\n\"*\207" [kwd element property :key get-text-property 0 plist-get "CATEGORY" :value] 4] first-match :input-file file-name-sans-extension file-name-nondirectory category info file] 7 (#$ . 118011)])
#@178 Return alternative title for HEADLINE, as a secondary string.
INFO is a plist used as a communication channel. If no optional
title is defined, fall-back to the regular title.
(defalias 'org-export-get-alt-title #[(headline info) "\303 ;\203 \304\305\n #\202 \306 A@\n\"*\2063 \307 ;\203, \304\305\n #\2022 \306 A@\n\"*\207" [headline element property :alt-title get-text-property 0 plist-get :title] 4 (#$ . 119183)])
#@110 Non-nil when HEADLINE is the first sibling in its sub-tree.
INFO is a plist used as a communication channel.
(defalias 'org-export-first-sibling-p #[(headline info) "\303 \"\211:\204 \n;\205 \304\202 \n@9\205 \n@)\300=?\207" [headline info element org-export-get-previous-element plain-text] 4 (#$ . 119618)])
#@109 Non-nil when HEADLINE is the last sibling in its sub-tree.
INFO is a plist used as a communication channel.
(defalias 'org-export-last-sibling-p #[(headline info) "\302 \"?\207" [headline info org-export-get-next-element] 3 (#$ . 119941)])
#@400 Return date value for the current document.
INFO is a plist used as a communication channel. FMT, when
non-nil, is a time format string that will be applied on the date
if it consists in a single timestamp object. It defaults to
`org-export-date-timestamp-format' when nil.
A proper date can be a secondary string, a string or nil. It is
meant to be translated with `org-export-data' or alike.
(defalias 'org-export-get-date #[(info &optional fmt) "\305\306\" \206 \n\211\204 \307\202D \203C A\204C @\211 :\204- \f;\2055 \310\2025 \f@9\2055 \f@)\311=\203C \312 @ \"\202D *\207" [info fmt org-export-date-timestamp-format date element plist-get :date nil plain-text timestamp org-timestamp-format] 4 (#$ . 120189)])
#@52 Take link text S and make a safe target out of it.
(defalias 'org-export-solidify-link-text #[(s) "\302 \303\216\304\305\306 \307\"\310#*\207" [save-match-data-internal s match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] mapconcat identity org-split-string "[^a-zA-Z0-9_.-:]+" "-"] 5 (#$ . 120924)])
#@96 Return format string for code reference link.
PATH is the link path. DESC is its description.
(defalias 'org-export-get-coderef-format #[(path desc) "\303 \304\216 \204
\305\202# \306\307\310\n\311Q! \"\203\" \312\305\313\211 $\202# *\207" [save-match-data-internal desc path match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] "%s" string-match regexp-quote "(" ")" replace-match t] 5 (#$ . 121271)])
#@466 Non-nil if LINK object points to an inline image.
Optional argument is a set of RULES defining inline images. It
is an alist where associations have the following shape:
(TYPE . REGEXP)
Applying a rule means apply REGEXP against LINK's path when its
type is TYPE. The function will return a non-nil value if any of
the provided rules is non-nil. The default rule is
`org-export-default-inline-image-rule'.
This only applies to links without a description.
(defalias 'org-export-inline-image-p #[(link &optional rules) "\211:\204 \305\202 @9\203 AA\202 )?\2051 \306\n\206# \30720 \310\311\n\"\210\3050*\207" [link element rules org-export-default-inline-image-rule case-fold-search nil t exit mapc #[(rule) "\304 ;\203 \305\306\n #\202 \307 A@\n\"* @\230\205A \310 A\311 ;\2032 \305\306\n #\2028 \307 A@\n\"*\"\205A \312\313\314\"\207" [link element property rule :type get-text-property 0 plist-get string-match :path throw exit t] 6]] 4 (#$ . 121722)])
#@197 Resolve a code reference REF.
INFO is a plist used as a communication channel.
Return associated line number in source code, or REF itself,
depending on src-block or example element's switches.
(defalias 'org-export-resolve-coderef #[(ref info) "\301\302\303\"\304\305\306%\207" [info org-element-map plist-get :parse-tree (example-block src-block) #[(el) "\306\307!rq\210\310\216\311\312 \n;\203 \313\314 \n#\202\" \315\nA@ \"*!c\210\316\317 \n;\2038 \313\314 \n#\202> \315\nA@ \"*\206C \f! \320\321\322\323
\324\325%\" \326 \324\325#\205\245 \327 \n;\203l \313\314 \n#\202r \315\nA@ \"*\203{ \202\245 \330 \n;\203\214 \313\314 \n#\202\222 \315\nA@ \"*\331=\203\243 \332 \"\333 \\\202\245 \333 -\207" [#1=#:temp-buffer el element property org-coderef-label-format label-fmt generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#1# buffer-name kill-buffer] 2] org-trim :value get-text-property 0 plist-get regexp-quote :label-fmt format "^.*?\\S-.*?\\([ ]*\\(%s\\)\\)[ ]*$" replace-regexp-in-string "%s" nil t re-search-backward :use-labels :number-lines continued org-export-get-loc line-number-at-pos ref ref-re info] 8] first-match] 6 (#$ . 122712)])
#@647 Return LINK destination.
INFO is a plist holding contextual information.
Return value can be an object, an element, or nil:
- If LINK path matches a target object (i.e. <<path>>) return it.
- If LINK path exactly matches the name affiliated keyword
(i.e. #+NAME: path) of an element, return that element.
- If LINK path exactly matches any headline name, return that
element. If more than one headline share that name, priority
will be given to the one with the closest common ancestor, if
any, or the first one in the parse tree otherwise.
- Otherwise, return nil.
Assume LINK type is "fuzzy". White spaces are not
significant.
(defalias 'org-export-resolve-fuzzy-link #[(link info) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\211\310H\312= \313\f\203+ \314\315O\202, ! \311\"\316\"\206E \311\317\"\316\320\321\322\"#\211\"\316\" #\323
#\324# $\f\204_ $\324=\204_ $\202\324 \f\204\200 \325\311\"\326\"\327\330\"\331%\211 %\205| \332
%##)\206\324 \f\204\242 \325\311\"\326\"&\333\"\331%\211 %\205\236 \332
%##)\206\324 \334 '\3352\323 \336\337\340!\211 (\204\275 \311\"\326\"C\202\304 (\341(!B)\"\210\f?\205\322 \332
\315##0)-\207" [link element property raw-path match-title-p path :path get-text-property 0 plist-get 42 org-split-string 1 nil :resolve-fuzzy-link-cache plist-put make-hash-table :test equal gethash not-found org-element-map :parse-tree target #[(blob) "\304\305 ;\203 \306\307\n #\202 \310 A@\n\"*! \232\205 \207" [blob element property path org-split-string :value get-text-property 0 plist-get] 5] first-match puthash #[(el) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\211\205& \311 !\f\232\205& )\207" [el element property name path :name get-text-property 0 plist-get org-split-string] 5] #[(name data) "\302\303\304 \305%\207" [data info org-element-map headline #[(headline) "\304\305\306\307\310 ;\203 \311\312\n #\202 \313 A@\n\"*#! \232\205$ \207" [headline element property name org-split-string replace-regexp-in-string "\\[[0-9]+%\\]\\|\\[[0-9]+/[0-9]+\\]" "" :raw-value get-text-property 0 plist-get] 8] first-match] 6] exit mapc #[(parent) " \n\"\211\205
\304\305 \")\207" [find-headline path parent foundp throw exit] 4] org-export-get-parent-headline org-export-get-genealogy info link-cache cached match org-element-all-elements find-headline parent-hl] 8 (#$ . 123907)])
#@241 Return headline referenced as LINK destination.
INFO is a plist used as a communication channel.
Return value can be the headline element matched in current parse
tree, a file name or nil. Assume LINK type is either "id" or
"custom-id".
(defalias 'org-export-resolve-id-link #[(link info) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311\310\f\312\"\313\314\f\315%\206. \316 \310\f\317\"\"A)\207" [link element property id info :path get-text-property 0 plist-get org-element-map :parse-tree headline #[(headline) "\304 ;\203 \305\306\n #\202 \307 A@\n\"* \230\204: \310 ;\203. \305\306\n #\2024 \307 A@\n\"* \230\205; \207" [headline element property id :ID get-text-property 0 plist-get :CUSTOM_ID] 4] first-match assoc :id-alist] 6 (#$ . 126287)])
#@192 Return radio-target object referenced as LINK destination.
INFO is a plist used as a communication channel.
Return value can be a radio-target object or nil. Assume LINK
has type "radio".
(defalias 'org-export-resolve-radio-link #[(link info) "\305\306\307\310 ;\203 \311\312\n #\202 \313 A@\n\"*#\314\313\f\315\"\316\317\f\320%)\207" [link element property path info replace-regexp-in-string "[
\n]+" " " :path get-text-property 0 plist-get org-element-map :parse-tree radio-target #[(radio) "\304\305\306\307\310 ;\203 \311\312\n #\202 \313 A@\n\"*#\314\211 \314\211\315&\315=\205+ \207" [radio element property path compare-strings replace-regexp-in-string "[
\n]+" " " :value get-text-property 0 plist-get nil t] 8] first-match] 7 (#$ . 127060)])
#@1042 Return ordinal number of an element or object.
ELEMENT is the element or object considered. INFO is the plist
used as a communication channel.
Optional argument TYPES, when non-nil, is a list of element or
object types, as symbols, that should also be counted in.
Otherwise, only provided element's type is considered.
Optional argument PREDICATE is a function returning a non-nil
value if the current element or object should be counted in. It
accepts two arguments: the element or object being considered and
the plist used as a communication channel. This allows counting
only a certain type of object (i.e. inline images).
Return value is a list of numbers if ELEMENT is a headline or an
item. It is nil for keywords. It represents the footnote number
for footnote definitions and footnote references. If ELEMENT is
a target, return the same value as if ELEMENT was the closest
table, item or headline containing the target. In any other
case, return the sequence number of ELEMENT among elements or
objects of the same type.
(defalias 'org-export-get-ordinal #[(element info &optional types predicate) "\211:\204 ;\205 \306\202 @9\205 @)\307=\203d \310!\311\312\311 :\203a @\211\211:\204@ ;\205H \306\202H @9\205H @)\313>\203V \n\311\211\202W \312\203a A\211\202) \f,\211:\204t ;\205| \306\202| @9\205| @) \314
\315\"\203\215 \316 \"\202\314
\317\"\203\334 \320 ;\203\247 \321\322 #\202\256 \323A@ \"* !\324\325 ;\203\305 \321\322 #\202\314 \323A@ \"*!\326!!\327!!$)\202\330
\331\"\203\353 \332 \"\202\322 \"\333\323 \334\"#\206\211:\204 ;\205\306\202@9\205@)\335 \336%))\207" [element #1=#:--cl-var-- parent #2=#:--cl-var-- #3=#:--cl-var-- #4=#:temp plain-text target org-export-get-genealogy nil t (footnote-definition footnote-reference headline item table) eql headline org-export-get-headline-number item :structure get-text-property 0 plist-get org-list-get-item-number :begin org-list-prevs-alist org-list-parents-alist memql (footnote-definition footnote-reference) org-export-get-footnote-number org-element-map :parse-tree #[(el) " =\203 \nT\207 \204 \nT\305\207 \f\"\205 \nT\305\207" [element el counter predicate info nil] 3] first-match info property struct counter types] 7 (#$ . 127839)])
#@134 Return accumulated lines of code up to ELEMENT.
INFO is the plist used as a communication channel.
ELEMENT is excluded from count.
(defalias 'org-export-get-loc #[(element info) "\303\304\305 \306\"\307\310\n\211:\204 \n;\205! \311\202! \n@9\205! \n@)E\312 \313%\210)\207" [loc info element 0 org-element-map plist-get :parse-tree src-block example-block plain-text #[(el) " =\206u \211:\204 ;\205 \306\202 @9\205 @)\307>\204& \310\207\311 ;\2037 \312\313\n #\202= \314 A@\n\"*\211\205p \315\316\317 ;\203V \312\313\n #\202\\ \314 A@\n\"*!! \320=\203j \f\202m
\f\\\211))\205u \310\207" [el element property linums lines loc plain-text (src-block example-block) nil :number-lines get-text-property 0 plist-get org-count-lines org-trim :value new] 7] first-match] 7 (#$ . 130149)])
#@319 Clean source code and extract references out of it.
ELEMENT has either a `src-block' an `example-block' type.
Return a cons cell whose CAR is the source code, cleaned from any
reference and protective comma and CDR is an alist between
relative line number (integer) and name of code reference on that
line (string).
(defalias 'org-export-unravel-code #[(element) "\306\307\310\311\312\310\313\314\315\n\n;\203 \316\306 \n#\202! \317\nA@ \"*## \320\321\n\n;\2037 \316\306 \n#\202= \317\nA@ \"*\206B
! \322\323\310\324\325\307\326%\" \327\330\331\332\f\314\"\314#! -B\207" [line refs element property code org-coderef-label-format 0 nil replace-regexp-in-string "\\`\\([ ]*\n\\)+" #1="" "\\([ ]*\n\\)*[ ]*\\'" "\n" :value get-text-property plist-get regexp-quote :label-fmt format "^.*?\\S-.*?\\([ ]*\\(%s\\)[ ]*\\)$" "%s" "\\([-a-zA-Z0-9_ ]+\\)" t org-element-normalize-string mapconcat #[(loc) "T\304 \n\"\204\f \n\207\305\306\n\"B B\307\310\311\211\n\312%\207" [line with-ref-re loc refs string-match match-string 3 replace-match #1# nil 1] 6] org-split-string label-fmt with-ref-re] 10 (#$ . 130962)])
#@861 Format CODE by applying FUN line-wise and return it.
CODE is a string representing the code to format. FUN is
a function. It must accept three arguments: a line of
code (string), the current line number (integer) or nil and the
reference associated to the current line (string) or nil.
Optional argument NUM-LINES can be an integer representing the
number of code lines accumulated until the current code. Line
numbers passed to FUN will take it into account. If it is nil,
FUN's second argument will always be nil. This number can be
obtained with `org-export-get-loc' function.
Optional argument REF-ALIST can be an alist between relative line
number (i.e. ignoring NUM-LINES) and the name of the code
reference on it. If it is nil, FUN's third argument will always
be nil. It can be obtained through the use of
`org-export-unravel-code' function.
(defalias 'org-export-format-code #[(code fun &optional num-lines ref-alist) "\303\304\"\305\306\307\310\n\304#!*\207" [code --line --locs org-split-string "\n" 0 org-element-normalize-string mapconcat #[(--loc) "T\211 \236A \f
\205
\\\n#)\207" [--line ref-alist --ref fun --loc num-lines] 5]] 5 (#$ . 132096)])
#@489 Return source code from ELEMENT, formatted in a standard way.
ELEMENT is either a `src-block' or `example-block' element. INFO
is a plist used as a communication channel.
This function takes care of line numbering and code references
inclusion. Line numbers, when applicable, appear at the
beginning of the line, separated from the code by two white
spaces. Code references, on the other hand, appear flushed to
the right, separated by six white spaces from the widest line of
code.
(defalias 'org-export-format-code-default #[(element info) "\306!\211@\307\n\310\"\211\204 \311\202\233 \312 ;\203% \313\314\f#\202+ \315A@\f\"*\2051 A \316 ;\203C \313\314\f#\202I \315A@\f\"* \317 \320\"\203\\ \321 \"\202e \317 \322\"\205e \314)\211 \205w \323\324\325 G \\!G\" \326\327\330\331 \"\" \204\211 \314\202\220 \323 \"G\\ \332\n\333
$,+\207" [element code-info code code-lines property refs org-export-unravel-code org-split-string "\n" "" :retain-labels get-text-property 0 plist-get :number-lines eql continued org-export-get-loc new format "%%%ds " number-to-string apply max mapcar length org-export-format-code #[(loc line-num ref) "\205 \306 \"\211 \f\205 \307\310
\\ G\nG\\Z\311\"\306\312\f\"PQ)\207" [num-fmt line-num number-str loc ref max-width format make-string 6 32 "(%s)"] 7] #1=#:temp info num-start num-fmt max-width] 6 (#$ . 133284)])
#@93 Non-nil when TABLE has a special column.
All special columns will be ignored during export.
(defalias 'org-export-table-has-special-column-p #[(table) "\303\3042' \305\306 \211:\204 \307\202 \n@9\203 \nAA\202 \n)\"\210\310=0)\207" [special-column-p table element empty exit mapc #[(row) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311=\205f \211:\204( \312\2025 @9\2034 AA\2025 )@\211:\204A \312\202N @9\203M AA\202N )\211\313\235\203\\ \314\211\202e ?\206e \315\316\312\")\207" [row element property value special-column-p :type get-text-property 0 plist-get standard nil (("/") ("#") ("!") ("$") ("*") ("_") ("^")) special throw exit] 5] nil special] 4 (#$ . 134679)])
#@148 Non-nil when TABLE has a header.
INFO is a plist used as a communication channel.
A table has a header when it contains at least two row groups.
(defalias 'org-export-table-has-header-p #[(table info) "\305\306\"\206 \305\307\306\310\311\312\"#\211\306\"\313\n \"\206, \314\315 \316\n\317\n\320\321\322% #*)\207" [info cache table row-flag rowgroup plist-get :table-header-cache plist-put make-hash-table :test eq gethash 1 nil puthash org-element-map table-row #[(row) "\305V\203 \306\207 \2030 \307\n ;\203 \310\311\f #\202# \312 A@\f\"*\313=\2030 T\314\211\207 ?\205U \307\n ;\203F \310\311\f #\202L \312 A@\f\"*\315=\205U \306\314\207" [rowgroup row-flag row element property 1 t :type get-text-property 0 plist-get rule nil standard] 4] first-match] 8 (#$ . 135379)])
#@146 Non-nil if TABLE-ROW is considered special.
INFO is a plist used as the communication channel.
All special rows will be ignored during export.
(defalias 'org-export-table-row-is-special-p #[(table-row info) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\312=\205\244 \211:\204( \313\2025 @9\2034 AA\2025 )@\211:\204A \313\202N @9\203M AA\202N )\211\314\232\206\243 \315 \316\f ;\203j \307\310\n #\202p \311 A@\n\"+!\203{ \317\235\206\243 \320 \3212\242 \322\323\211:\204\216 \313\202\233 @9\203\232 AA\202\233 )\"\210
\324=0))\207" [table-row element property first-cell blob special-row-p :type get-text-property 0 plist-get standard nil ("/") org-export-table-has-special-column-p :parent (("^") ("_") ("$") ("!")) empty exit mapc #[(cell) "\211:\204 \304\202 @9\203 AA\202 )\211?\206< \nA\2048 \n@;\2038 \305\306\n@\"\2038 \307\211\202< \310\311\304\")\207" [cell element value special-row-p nil string-match "\\`<[lrc]?\\([0-9]+\\)?>\\'" cookie throw exit] 4] cookie] 6 (#$ . 136179)])
#@233 Return TABLE-ROW's group number, as an integer.
INFO is a plist used as the communication channel.
Return value is the group number, as an integer, or nil for
special rows and rows separators. First group is also table's
header.
(defalias 'org-export-table-row-group #[(table-row info) "\306\307\"\206 \306\310\307\311\312\313\"#\211\307\"\314\n \"\206e \315\n ;\203- \316\317\f #\2023 \306 A@\f\"*\320=\203= \321\202e \317\321 \322\n \323 ;\203X \316\317\f #\202^ \306 A@\f\"+\302\324\325%*)\207" [info cache table-row element property row-flag plist-get :table-row-group-cache plist-put make-hash-table :test eq gethash :type get-text-property 0 rule nil org-element-map :parent #[(row) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\312=\203\" \313\202+ \204+ \fT\314
=\2057 \315
\f#\207" [row element property row-flag group table-row :type get-text-property 0 plist-get rule nil t puthash cache] 4] first-match group blob] 7 (#$ . 137208)])
#@187 Return TABLE-CELL contents width.
INFO is a plist used as the communication channel.
Return value is the width given by the last width cookie in the
same column as TABLE-CELL, or nil.
(defalias 'org-export-table-cell-width #[(table-cell info) "\306 \n;\203 \307\310 \n#\202 \311\nA@ \"+\211 \306 \n;\203. \307\310 \n#\2024 \311\nA@ \"+ \f\211:\204A \312\202N \n@9\203M \nAA\202N \n)\211 G\211 >GZ \311 \313\"\206u \311\314 \313\315\316\317\"#\211 \313\" \320
\"\206\211 \321
\322\323\" #\211 H\211 \323=\204\234 \202D\312 !
\211:\204\252 \312\202\267 \n@9\203\266 \nAA\202\267 \n)\312 \211 \"\203:\"@\324\f \"\2031\f\211:\204\327 \312\202\344 \n@9\203\343 \nAA\202\344 \n) \234\211:\204\362 \312\202\377 \n@9\203\376 \nAA\202\377 \n)\211 @ # \2030 A\2040#;\2030\325\326#\"\2030\327\330#\"\2030\331\327\330#\"!!*\"A\211\"\204\300 \312 !I+.\207" [table-cell blob element property row table :parent get-text-property 0 plist-get nil :table-cell-width-cache plist-put make-hash-table :test eq gethash puthash make-vector empty org-export-table-row-is-special-p string-match "\\`<[lrc]?\\([0-9]+\\)?>\\'" match-string 1 string-to-number cells columns column info cache width-vector value cookie-width --dolist-tail-- cookie] 8 (#$ . 138186)])
#@401 Return TABLE-CELL contents alignment.
INFO is a plist used as the communication channel.
Return alignment as specified by the last alignment cookie in the
same column as TABLE-CELL. If no such cookie is found, a default
alignment value will be deduced from fraction of numbers in the
column (see `org-table-number-fraction' for more information).
Possible values are `left', `right' and `center'.
(defalias 'org-export-table-cell-alignment #[(table-cell info) "\306\307!\210\310 \n;\203 \311\312 \n#\202 \313\nA@ \"+\211 \310 \n;\2032 \311\312 \n#\2028 \313\nA@ \"+ \f\211:\204E \314\202R \n@9\203Q \nAA\202R \n)\211 &G\211 '&>GZ (\313)\315\"\206y \313\316)\315\317\320\321\"#\211)\315\" *\322
*\"\206\215 \323
\324'\314\"*#\211 +(H\206\312\211\314\211 , - . /\f\310 \n;\203\265 \311\312 \n#\202\273 \313\nA@ \"+\211:\204\306 \314\202\323 \n@9\203\322 \nAA\202\323 \n)\314 \211 0\203\3330@\325\f)\"\203M\f\211:\204\363 \314\202 \n@9\203\377 \nAA\202 \n)(\234\211:\204\314\202\n@9\203\nAA\202\n)\211 1\203I1A\204I1@;\203I\326\3271@\"\203I\330\3311@\"\203I\330\3311@\"-)\202\322\332\f\n;\203^\311\312 \n#\202d\313\nA@ \"*\333=\204\322-\204\322\334\f\211:\204{\314\202\210\n@9\203\207\nAA\202\210\n)(\234\211:\204\226\314\202\243\n@9\203\242\nAA\202\243\n))\" 1.T.\32621\"\204\3111\335\230\203\303,\204\311\314,\202\321\336,/T/)0A\2110\204\334 *+(-\337\232\203\353\340\202-\341\232\203\366\342\202-\343\232\203\344\202\345/!.\2453Y\203\342\202\340I,.\207" [table-cell blob element property row table require org-table :parent get-text-property 0 plist-get nil :table-cell-alignment-cache plist-put make-hash-table :test eq gethash puthash make-vector org-export-table-row-is-special-p string-match "\\`<\\([lrc]\\)?\\([0-9]+\\)?>\\'" match-string 1 :type rule org-export-data "" t "l" left "r" right "c" center float cells columns column info cache align-vector previous-cell-number-p cookie-align total-cells number-cells --dolist-tail-- value org-table-number-regexp org-table-number-fraction] 8 (#$ . 139495)])
#@369 Return TABLE-CELL borders.
INFO is a plist used as a communication channel.
Return value is a list of symbols, or nil. Possible values are:
`top', `bottom', `above', `below', `left' and `right'. Note:
`top' (resp. `bottom') only happen for a cell in the first
row (resp. last row) of the table, ignoring table rules, if any.
Returned borders ignore special rows.
(defalias 'org-export-table-cell-borders #[(table-cell info) "\306 \n;\203 \307\310 \n#\202 \311\nA@ \"+ \312! \313\211 \3142^ \315\316\f\317
\211:\2048 \313\202E \n@9\203D \nAA\202E \n)!>A\"\210\203V \320B\321B\2110\210)\313 \3142\232 \315\322\f
\211:\204u \313\202\202 \n@9\203\201 \nAA\202\202 \n)>A\"\210\203\222 \323B\324B\2110\210)\3142\346 \f\211:\204\253 \313\202\270 \n@9\203\267 \nAA\202\270 \n)\211 G>GZ) \315\325\317
\211:\204\324 \313\202\341 \n@9\203\340 \nAA\202\341 \n)!\")0\210+\207" [table-cell blob element property row table :parent get-text-property 0 plist-get org-export-get-parent-table nil exit mapc #[(row) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\312=\203! \313\211\207\314\f\"?\205: \2036 \315\316\317
B\211\"\207\315\316\320\"\207" [row element property rule-flag info borders :type get-text-property 0 plist-get rule t org-export-table-row-is-special-p throw exit above nil] 4] reverse above top #[(row) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\312=\203! \313\211\207\314\f\"?\205: \2036 \315\316\317
B\211\"\207\315\316\320\"\207" [row element property rule-flag info borders :type get-text-property 0 plist-get rule t org-export-table-row-is-special-p throw exit below nil] 4] below bottom #[(row) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*\312=?\205\257 \211:\204) \313\2026 @9\2035 AA\2026 )@\211:\204B \313\202O @9\203N AA\202O )\314\232\205\257 \315\316\211:\204b \313\202o @9\203n AA\202o )\"\f\310U\204\201 \fS\234\317\235\204\211 \f\234\320\235\203\215 \321
B\fT GU\204\236 \fT\234\322\235\204\246 \f\234\323\235\203\252 \324
B\325\326\313\")\207" [row element property column-groups column borders :type get-text-property 0 plist-get rule nil ("/") mapcar #[(cell) "\211:\204 \303\202 @9\203 AA\202 )\211\304\235\205\" \n@)\207" [cell element value nil (("<") ("<>") (">") nil)] 3] (">" "<>") ("<" "<>") left ("<" "<>") (">" "<>") right throw exit] 5] borders rule-flag cells column] 6 (#$ . 141629)])
#@110 Non-nil when TABLE-CELL is at the beginning of a row group.
INFO is a plist used as a communication channel.
(defalias 'org-export-table-cell-starts-colgroup-p #[(table-cell info) "\305\306 \n;\203 \307\310 \n#\202 \311\nA@ \"+\300\312\f\313%=\206+ \314\315\f\">\207" [table-cell blob element property info org-element-map :parent get-text-property 0 plist-get identity first-match left org-export-table-cell-borders] 6 (#$ . 144043)])
#@104 Non-nil when TABLE-CELL is at the end of a row group.
INFO is a plist used as a communication channel.
(defalias 'org-export-table-cell-ends-colgroup-p #[(table-cell info) "\305\306 \n;\203 \307\310 \n#\202 \311\nA@ \"+\211:\204% \312\2022 \n@9\2031 \nAA\2022 \n)!@=\206@ \313\314\f\">\207" [table-cell blob element property info last :parent get-text-property 0 plist-get nil right org-export-table-cell-borders] 6 (#$ . 144494)])
#@112 Non-nil when TABLE-ROW is at the beginning of a column group.
INFO is a plist used as a communication channel.
(defalias 'org-export-table-row-starts-rowgroup-p #[(table-row info) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311=\206! \312 \"?\205M \313\211:\2041 \314\202> @9\203= AA\202> )@ \" \315\f>\206L \316\f>)\207" [table-row element property info borders :type get-text-property 0 plist-get rule org-export-table-row-is-special-p org-export-table-cell-borders nil top above] 5 (#$ . 144942)])
#@106 Non-nil when TABLE-ROW is at the end of a column group.
INFO is a plist used as a communication channel.
(defalias 'org-export-table-row-ends-rowgroup-p #[(table-row info) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311=\206! \312 \"?\205M \313\211:\2041 \314\202> @9\203= AA\202> )@ \" \315\f>\206L \316\f>)\207" [table-row element property info borders :type get-text-property 0 plist-get rule org-export-table-row-is-special-p org-export-table-cell-borders nil bottom below] 5 (#$ . 145459)])
#@106 Non-nil when TABLE-ROW is the first table header's row.
INFO is a plist used as a communication channel.
(defalias 'org-export-table-row-starts-header-p #[(table-row info) "\302\303! \"\205 \304 \"\205 \305 \"\306U\207" [table-row info org-export-table-has-header-p org-export-get-parent-table org-export-table-row-starts-rowgroup-p org-export-table-row-group 1] 3 (#$ . 145971)])
#@105 Non-nil when TABLE-ROW is the last table header's row.
INFO is a plist used as a communication channel.
(defalias 'org-export-table-row-ends-header-p #[(table-row info) "\302\303! \"\205 \304 \"\205 \305 \"\306U\207" [table-row info org-export-table-has-header-p org-export-get-parent-table org-export-table-row-ends-rowgroup-p org-export-table-row-group 1] 3 (#$ . 146364)])
#@189 Return TABLE-ROW number.
INFO is a plist used as a communication channel. Return value is
zero-based and ignores separators. The function returns nil for
special columns and separators.
(defalias 'org-export-table-row-number #[(table-row info) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311=\2051 \312 \"?\2051 \307 \313\314!\300\315 \316%)\207" [table-row element property info number :type get-text-property 0 plist-get standard org-export-table-row-is-special-p org-element-map org-export-get-parent-table #[(row) " =\203 \n\207\305 ;\203 \306\307\f #\202 \310 A@\f\"*\311=\205) \nT\312\207" [row table-row number element property :type get-text-property 0 plist-get standard nil] 4] first-match] 6 (#$ . 146752)])
#@199 Return TABLE dimensions.
INFO is a plist used as a communication channel.
Return value is a CONS like (ROWS . COLUMNS) where
ROWS (resp. COLUMNS) is the number of exportable
rows (resp. columns).
(defalias 'org-export-table-dimensions #[(table info) "\305\306\211\307 \310\311\f$\210\307\n\312\313\f$\210 +B\207" [rows columns first-row table info nil 0 org-element-map table-row #[(row) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311=\205( T\f?\205( \211\207" [row element property rows first-row :type get-text-property 0 plist-get standard] 4] table-cell #[(cell) "T\211\207" [columns] 2]] 5 (#$ . 147493)])
#@299 Return address of a regular TABLE-CELL object.
TABLE-CELL is the cell considered. INFO is a plist used as
a communication channel.
Address is a CONS cell (ROW . COLUMN), where ROW and COLUMN are
zero-based index. Only exportable cells are considered. The
function returns nil for other cells.
(defalias 'org-export-table-cell-address #[(table-cell info) "\306 \n;\203 \307\310 \n#\202 \311\nA@ \"+ \312\f
\"\211 \2053 \310 \313\f\300\314
\315%)B*\207" [table-cell blob element property table-row info :parent get-text-property 0 plist-get org-export-table-row-number org-element-map #[(cell) " =\203 \n\207\nT\303\207" [cell table-cell col-count nil] 2] first-match row-number col-count] 8 (#$ . 148127)])
#@296 Return regular table-cell object at ADDRESS in TABLE.
Address is a CONS cell (ROW . COLUMN), where ROW and COLUMN are
zero-based index. TABLE is a table type element. INFO is
a plist used as a communication channel.
If no table-cell, among exportable cells, is found at ADDRESS,
return nil.
(defalias 'org-export-get-table-cell-at #[(address table info) "A\306\307@\306 \307
\310\311
\312%*\313\314
\312%*\207" [address column-count column-pos row-count row-pos table 0 org-element-map table-row #[(row) "\305 ;\203 \306\307\n #\202 \310 A@\n\"*\311=\203 \312\207 \fU\203' \207 T\312\207" [row element property row-count row-pos :type get-text-property 0 plist-get rule nil] 4] first-match table-cell #[(cell) " U\203 \n\207T\303\207" [column-count column-pos cell nil] 2] info] 7 (#$ . 148858)])
#@424 Collect headlines in order to build a table of contents.
INFO is a plist used as a communication channel.
When optional argument N is an integer, it specifies the depth of
the table of contents. Otherwise, it is set to the value of the
last headline level. See `org-export-headline-levels' for more
information.
Return a list of all exportable headlines as parsed elements.
Footnote sections, if any, will be ignored.
(defalias 'org-export-collect-headlines #[(info &optional n) "\303\304\"\305\n!\203 \n ^\202 \306\303\307\"\310\311$)\207" [info limit n plist-get :headline-levels wholenump org-element-map :parse-tree headline #[(headline) "\306 ;\203 \307\310\n #\202 \311 A@\n\"*?\205) \312 \"\211
X\205( )\207" [headline element property info level n :footnote-section-p get-text-property 0 plist-get org-export-get-relative-level] 5]] 5 (#$ . 149685)])
#@463 Collect referenceable elements of a determined type.
TYPE can be a symbol or a list of symbols specifying element
types to search. Only elements with a caption are collected.
INFO is a plist used as a communication channel.
When non-nil, optional argument PREDICATE is a function accepting
one argument, an element of type TYPE. It returns a non-nil
value when that element should be collected.
Return a list of all elements found, in order of appearance.
(defalias 'org-export-collect-elements #[(type info &optional predicate) "\302\303\304\" \305$\207" [info type org-element-map plist-get :parse-tree #[(element) "\303;\203 \304\305 #\202 \306A@ \"*\205& \n\203% \n!\205& \207" [element property predicate :caption get-text-property 0 plist-get] 4]] 5 (#$ . 150572)])
#@123 Build a list of tables.
INFO is a plist used as a communication channel.
Return a list of table elements with a caption.
(defalias 'org-export-collect-tables #[(info) "\301\302\"\207" [info org-export-collect-elements table] 3 (#$ . 151369)])
#@444 Build a list of figures.
INFO is a plist used as a communication channel. PREDICATE is
a function which accepts one argument: a paragraph element and
whose return value is non-nil when that element should be
collected.
A figure is a paragraph type element, with a caption, verifying
PREDICATE. The latter has to be provided since a "figure" is
a vague concept that may depend on back-end.
Return a list of elements recognized as figures.
(defalias 'org-export-collect-figures #[(info predicate) "\302\303 #\207" [info predicate org-export-collect-elements paragraph] 4 (#$ . 151621)])
#@132 Build a list of src blocks.
INFO is a plist used as a communication channel.
Return a list of src-block elements with a caption.
(defalias 'org-export-collect-listings #[(info) "\301\302\"\207" [info org-export-collect-elements src-block] 3 (#$ . 152219)])
#@466 Smart quotes translations.
Alist whose CAR is a language string and CDR is an alist with
quote type as key and a plist associating various encodings to
their translation as value.
A quote type can be any symbol among `opening-double-quote',
`closing-double-quote', `opening-single-quote',
`closing-single-quote' and `apostrophe'.
Valid encodings include `:utf-8', `:html', `:latex' and
`:texinfo'.
If no translation is found, the quote character is left as-is.
(defconst org-export-smart-quotes-alist '(("da" (opening-double-quote :utf-8 "»" :html "»" :latex ">>" :texinfo "@guillemetright{}") (closing-double-quote :utf-8 "«" :html "«" :latex "<<" :texinfo "@guillemetleft{}") (opening-single-quote :utf-8 "›" :html "›" :latex "\\frq{}" :texinfo "@guilsinglright{}") (closing-single-quote :utf-8 "‹" :html "‹" :latex "\\flq{}" :texinfo "@guilsingleft{}") (apostrophe :utf-8 "’" :html "’")) ("de" (opening-double-quote :utf-8 "„" :html "„" :latex "\"`" :texinfo "@quotedblbase{}") (closing-double-quote :utf-8 "“" :html "“" :latex "\"'" :texinfo "@quotedblleft{}") (opening-single-quote :utf-8 "‚" :html "‚" :latex "\\glq{}" :texinfo "@quotesinglbase{}") (closing-single-quote :utf-8 "‘" :html "‘" :latex "\\grq{}" :texinfo "@quoteleft{}") (apostrophe :utf-8 "’" :html "’")) ("en" (opening-double-quote :utf-8 "“" :html "“" :latex "``" :texinfo "``") (closing-double-quote :utf-8 "”" :html "”" :latex "''" :texinfo "''") (opening-single-quote :utf-8 "‘" :html "‘" :latex "`" :texinfo "`") (closing-single-quote :utf-8 "’" :html "’" :latex "'" :texinfo "'") (apostrophe :utf-8 "’" :html "’")) ("es" (opening-double-quote :utf-8 "«" :html "«" :latex "\\guillemotleft{}" :texinfo "@guillemetleft{}") (closing-double-quote :utf-8 "»" :html "»" :latex "\\guillemotright{}" :texinfo "@guillemetright{}") (opening-single-quote :utf-8 "“" :html "“" :latex "``" :texinfo "``") (closing-single-quote :utf-8 "”" :html "”" :latex "''" :texinfo "''") (apostrophe :utf-8 "’" :html "’")) ("fr" (opening-double-quote :utf-8 "« " :html "« " :latex "\\og " :texinfo "@guillemetleft{}@tie{}") (closing-double-quote :utf-8 " »" :html " »" :latex "\\fg{}" :texinfo "@tie{}@guillemetright{}") (opening-single-quote :utf-8 "« " :html "« " :latex "\\og " :texinfo "@guillemetleft{}@tie{}") (closing-single-quote :utf-8 " »" :html " »" :latex "\\fg{}" :texinfo "@tie{}@guillemetright{}") (apostrophe :utf-8 "’" :html "’")) ("no" (opening-double-quote :utf-8 "«" :html "«" :latex "\\guillemotleft{}" :texinfo "@guillemetleft{}") (closing-double-quote :utf-8 "»" :html "»" :latex "\\guillemotright{}" :texinfo "@guillemetright{}") (opening-single-quote :utf-8 "‘" :html "‘" :latex "`" :texinfo "`") (closing-single-quote :utf-8 "’" :html "’" :latex "'" :texinfo "'") (apostrophe :utf-8 "’" :html "’")) ("nb" (opening-double-quote :utf-8 "«" :html "«" :latex "\\guillemotleft{}" :texinfo "@guillemetleft{}") (closing-double-quote :utf-8 "»" :html "»" :latex "\\guillemotright{}" :texinfo "@guillemetright{}") (opening-single-quote :utf-8 "‘" :html "‘" :latex "`" :texinfo "`") (closing-single-quote :utf-8 "’" :html "’" :latex "'" :texinfo "'") (apostrophe :utf-8 "’" :html "’")) ("nn" (opening-double-quote :utf-8 "«" :html "«" :latex "\\guillemotleft{}" :texinfo "@guillemetleft{}") (closing-double-quote :utf-8 "»" :html "»" :latex "\\guillemotright{}" :texinfo "@guillemetright{}") (opening-single-quote :utf-8 "‘" :html "‘" :latex "`" :texinfo "`") (closing-single-quote :utf-8 "’" :html "’" :latex "'" :texinfo "'") (apostrophe :utf-8 "’" :html "’")) ("sv" (opening-double-quote :utf-8 "”" :html "”" :latex "’’" :texinfo "’’") (closing-double-quote :utf-8 "”" :html "”" :latex "’’" :texinfo "’’") (opening-single-quote :utf-8 "’" :html "’" :latex "’" :texinfo "`") (closing-single-quote :utf-8 "’" :html "’" :latex "’" :texinfo "'") (apostrophe :utf-8 "’" :html "’"))) (#$ . 152486))
#@116 List of regexps matching a quote or an apostrophe.
In every regexp, quote or apostrophe matched is put in group 1.
(defconst org-export-smart-quotes-regexps (list "\\`\\([\"']\\)\\(\\w\\|\\s.\\|\\s_\\|\\s(\\)" "\\`\\([\"']\\)\\(\\s-\\|\\s)\\|\\s.\\)" "\\`\\('\\)\\S-" "\\(?:\\s-\\|\\s(\\)\\([\"']\\)\\(?:\\w\\|\\s.\\|\\s_\\)" "\\(?:\\w\\|\\s.\\|\\s_\\)\\([\"']\\)\\(?:\\s-\\|\\s)\\|\\s.\\)" "\\S-\\('\\)\\S-" "\\(?:\\s-\\|\\s(\\)\\([\"']\\)\\'" "\\(?:\\w\\|\\s.\\|\\s_\\)\\([\"']\\)\\'" "\\S-\\('\\)\\'") (#$ . 156751))
#@459 Replace regular quotes with "smart" quotes in string S.
ENCODING is a symbol among `:html', `:latex', `:texinfo' and
`:utf-8'. INFO is a plist used as a communication channel.
The function has to retrieve information about string
surroundings in parse tree. It can only happen with an
unmodified string. Thus, if S has already been through another
process, a non-nil ORIGINAL optional argument will provide that
original string.
Return the new string.
(defalias 'org-export-activate-smart-quotes #[(s encoding info &optional original) "\306\232\203 \306\207\307 \206 \n\"\211\205E \310 \f;\203& \311\312
\f#\202, \313\fA@
\"*\206E ;\203D \314\315 \"\203D \316\312 \"G\206E \312 %\317 \206M \n\" &\320 '\321\232\204` \322\232\203\254 \204m &\204m \202\245 \204y '\323\"\202\245&\204\215 %\312U\203\215 '\324\"\202\245&\204\226 \202\245%\312U\203\245 '\325\"\202\245'\323!\202\245 \203\323 %\312U\203\323 \314\326(8\"\203\323 \327'\316\330\"\325\"\331\332\330%\202 \203\372 %\312U\203\372 \314(A@\"\203\372 \327'\316\330\"\324\"\331\332\330%\202 \203%\312V\203 \314(@\"\203 \327'\316\330\"\323\"\331\332\330%\333\334(8\335\331\332\330&\333\336(8\337\331\332\330&\333\340(8\341\331\332\330&&\203e\314\342(8\"\203e\327'\316\330\"\325\"\331\332\330%\202\244&\204\206\314\343(8\"\203\206\327'\316\330\"\324\"\331\332\330%\202\244&\203\244\314\344(8\"\203\244\327'\316\330\"\323\"\331\332\330%,\207" [s original info prev element property "" org-export-get-previous-element :post-blank get-text-property 0 plist-get string-match " *\\'" match-string org-export-get-next-element #[(q type) "\306\307\"\203 \307\202+ \306\310\"\203 \311\232\203 \312\202+ \313\202+ \311\232\203* \314\202+ \315\316\n\317\316 \320\"\f\"A\236A
\"\206> )\207" [type q key info org-export-smart-quotes-alist encoding eql apostrophe open "'" opening-single-quote opening-double-quote closing-single-quote closing-double-quote plist-get assoc :language] 6] "\"" "'" open close apostrophe 2 replace-match 1 nil t replace-regexp-in-string 3 #[(text) "\302\303 \"\304\"\207" [get-smart-quote text match-string 1 open] 4] 4 #[(text) "\302\303 \"\304\"\207" [get-smart-quote text match-string 1 close] 4] 5 #[(text) "\302\303 \"\304\"\207" [get-smart-quote text match-string 1 apostrophe] 4] 8 7 6 pre-blank next get-smart-quote org-export-smart-quotes-regexps] 8 (#$ . 157278)])
#@201 Return full genealogy relative to a given element or object.
BLOB is the element or object being considered.
Ancestors are returned from closest to farthest, the last one
being the full parse tree.
(defalias 'org-export-get-genealogy #[(blob) "\305\306 ;\203 \307\310\f #\202 \311 A@\f\"*\211\203( \nB\202 \n\237*\207" [blob parent genealogy element property nil :parent get-text-property 0 plist-get] 4 (#$ . 159749)])
#@85 Return BLOB parent headline or nil.
BLOB is the element or object being considered.
(defalias 'org-export-get-parent-headline #[(blob) "\304 \n;\203 \305\306 \n#\202 \307\nA@ \"*\211\203= \211:\204/ \n;\2057 \310\2027 \n@9\2057 \n@)\311=\203 )\207" [blob parent element property :parent get-text-property 0 plist-get plain-text headline] 5 (#$ . 160189)])
#@82 Return first element containing OBJECT or nil.
OBJECT is the object to consider.
(defalias 'org-export-get-parent-element #[(object) "\305 \n;\203 \306\307 \n#\202 \310\nA@ \"*\211\203= \211:\204/ \n;\2057 \311\2027 \n@9\2057 \n@)\f>\204 )\207" [object parent element property org-element-all-objects :parent get-text-property 0 plist-get plain-text] 5 (#$ . 160562)])
#@100 Return OBJECT parent table or nil.
OBJECT is either a `table-cell' or `table-element' type object.
(defalias 'org-export-get-parent-table #[(object) "\304 \n;\203 \305\306 \n#\202 \307\nA@ \"*\211\203= \211:\204/ \n;\2057 \310\2027 \n@9\2057 \n@)\311=\203 )\207" [object parent element property :parent get-text-property 0 plist-get plain-text table] 5 (#$ . 160949)])
#@381 Return previous element or object.
BLOB is an element or object. INFO is a plist used as
a communication channel. Return previous exportable element or
object, a string, or nil.
When optional argument N is a positive integer, return a list
containing up to N siblings before BLOB, from farthest to
closest. With any other non-nil value, return a list containing
all of them.
(defalias 'org-export-get-previous-element #[(blob info &optional n) "\306 ;\203 \307\310\n #\202 \311 A@\n\"+\211\211:\204+ ;\2053 \312\2023 @9\2053 @)\f\236A ;\203G \307\310\n #\202M \311 A@\n\"*
>\205V
)\206s \211:\204e \313\202r @9\203q AA\202r ))\313 \3142\213 \315\316\317!>A\"\2100*\207" [blob element property parent org-element-secondary-value-alist sec-value :parent get-text-property 0 plist-get plain-text nil exit mapc #[(obj) "\304 \305\">\2061 \n\204 \306\307\"\207\310\n!\204 B\211\207\n\311U\203) \306\307 \"\207\nS B\211\207" [obj info n prev plist-get :ignore-list throw exit wholenump 0] 4] reverse prev siblings] 6 (#$ . 161336)])
#@371 Return next element or object.
BLOB is an element or object. INFO is a plist used as
a communication channel. Return next exportable element or
object, a string, or nil.
When optional argument N is a positive integer, return a list
containing up to N siblings after BLOB, from closest to farthest.
With any other non-nil value, return a list containing all of
them.
(defalias 'org-export-get-next-element #[(blob info &optional n) "\306 ;\203 \307\310\n #\202 \311 A@\n\"+\211\211:\204+ ;\2053 \312\2023 @9\2053 @)\f\236A ;\203G \307\310\n #\202M \311 A@\n\"*
>A)\206s \211:\204c \313\202p @9\203o AA\202p )>A)\313 \3142\207 \315\316\"\210\2370*\207" [blob element property parent org-element-secondary-value-alist sec-value :parent get-text-property 0 plist-get plain-text nil exit mapc #[(obj) "\304 \305\">\2062 \n\204 \306\307\"\207\310\n!\204 B\211\207\n\311U\203* \306\307 \237\"\207\nS B\211\207" [obj info n next plist-get :ignore-list throw exit wholenump 0] 4] next siblings] 5 (#$ . 162416)])
#@410 Dictionary for export engine.
Alist whose CAR is the string to translate and CDR is an alist
whose CAR is the language string and CDR is a plist whose
properties are possible charsets and values translated terms.
It is used as a database for `org-export-translate'. Since this
function returns the string as-is if no translation was found,
the variable only needs to record values different from the
entry.
(defconst org-export-dictionary '(("%e %n: %c" ("fr" :default "%e %n : %c" :html "%e %n : %c")) ("Author" ("ca" :default "Autor") ("cs" :default "Autor") ("da" :default "Forfatter") ("de" :default "Autor") ("eo" :html "Aŭtoro") ("es" :default "Autor") ("fi" :html "Tekijä") ("fr" :default "Auteur") ("hu" :default "Szerzõ") ("is" :html "Höfundur") ("it" :default "Autore") ("ja" :html "著者" :utf-8 "著者") ("nl" :default "Auteur") ("no" :default "Forfatter") ("nb" :default "Forfatter") ("nn" :default "Forfattar") ("pl" :default "Autor") ("ru" :html "Автор" :utf-8 "Автор") ("sv" :html "Författare") ("uk" :html "Автор" :utf-8 "Автор") ("zh-CN" :html "作者" :utf-8 "作者") ("zh-TW" :html "作者" :utf-8 "作者")) ("Date" ("ca" :default "Data") ("cs" :default "Datum") ("da" :default "Dato") ("de" :default "Datum") ("eo" :default "Dato") ("es" :default "Fecha") ("fi" :html "Päivämäärä") ("hu" :html "Dátum") ("is" :default "Dagsetning") ("it" :default "Data") ("ja" :html "日付" :utf-8 "日付") ("nl" :default "Datum") ("no" :default "Dato") ("nb" :default "Dato") ("nn" :default "Dato") ("pl" :default "Data") ("ru" :html "Дата" :utf-8 "Дата") ("sv" :default "Datum") ("uk" :html "Дата" :utf-8 "Дата") ("zh-CN" :html "日期" :utf-8 "日期") ("zh-TW" :html "日期" :utf-8 "日期")) ("Equation" ("da" :default "Ligning") ("de" :default "Gleichung") ("es" :html "Ecuación" :default "Ecuación") ("fr" :ascii "Equation" :default "Équation") ("no" :default "Ligning") ("nb" :default "Ligning") ("nn" :default "Likning") ("sv" :default "Ekvation") ("zh-CN" :html "方程" :utf-8 "方程")) ("Figure" ("da" :default "Figur") ("de" :default "Abbildung") ("es" :default "Figura") ("ja" :html "図" :utf-8 "図") ("no" :default "Illustrasjon") ("nb" :default "Illustrasjon") ("nn" :default "Illustrasjon") ("sv" :default "Illustration") ("zh-CN" :html "图" :utf-8 "图")) ("Figure %d:" ("da" :default "Figur %d") ("de" :default "Abbildung %d:") ("es" :default "Figura %d:") ("fr" :default "Figure %d :" :html "Figure %d :") ("ja" :html "図%d: " :utf-8 "図%d: ") ("no" :default "Illustrasjon %d") ("nb" :default "Illustrasjon %d") ("nn" :default "Illustrasjon %d") ("sv" :default "Illustration %d") ("zh-CN" :html "图%d " :utf-8 "图%d ")) ("Footnotes" ("ca" :html "Peus de pàgina") ("cs" :default "Pozn\341mky pod carou") ("da" :default "Fodnoter") ("de" :html "Fußnoten" :default "Fußnoten") ("eo" :default "Piednotoj") ("es" :html "Nota al pie de página" :default "Nota al pie de página") ("fi" :default "Alaviitteet") ("fr" :default "Notes de bas de page") ("hu" :html "Lábjegyzet") ("is" :html "Aftanmálsgreinar") ("it" :html "Note a piè di pagina") ("ja" :html "脚注" :utf-8 "脚注") ("nl" :default "Voetnoten") ("no" :default "Fotnoter") ("nb" :default "Fotnoter") ("nn" :default "Fotnotar") ("pl" :default "Przypis") ("ru" :html "Сноски" :utf-8 "Сноски") ("sv" :default "Fotnoter") ("uk" :html "Примітки" :utf-8 "Примітки") ("zh-CN" :html "脚注" :utf-8 "脚注") ("zh-TW" :html "腳註" :utf-8 "腳註")) ("List of Listings" ("da" :default "Programmer") ("de" :default "Programmauflistungsverzeichnis") ("es" :default "Indice de Listados de programas") ("fr" :default "Liste des programmes") ("no" :default "Dataprogrammer") ("nb" :default "Dataprogrammer") ("zh-CN" :html "代码目录" :utf-8 "代码目录")) ("List of Tables" ("da" :default "Tabeller") ("de" :default "Tabellenverzeichnis") ("es" :default "Indice de tablas") ("fr" :default "Liste des tableaux") ("no" :default "Tabeller") ("nb" :default "Tabeller") ("nn" :default "Tabeller") ("sv" :default "Tabeller") ("zh-CN" :html "表格目录" :utf-8 "表格目录")) ("Listing %d:" ("da" :default "Program %d") ("de" :default "Programmlisting %d") ("es" :default "Listado de programa %d") ("fr" :default "Programme %d :" :html "Programme %d :") ("no" :default "Dataprogram") ("nb" :default "Dataprogram") ("zh-CN" :html "代码%d " :utf-8 "代码%d ")) ("See section %s" ("da" :default "jævnfør afsnit %s") ("de" :default "siehe Abschnitt %s") ("es" :default "vea seccion %s") ("fr" :default "cf. section %s") ("zh-CN" :html "参见第%d节" :utf-8 "参见第%s节")) ("Table" ("de" :default "Tabelle") ("es" :default "Tabla") ("fr" :default "Tableau") ("ja" :html "表" :utf-8 "表") ("zh-CN" :html "表" :utf-8 "表")) ("Table %d:" ("da" :default "Tabel %d") ("de" :default "Tabelle %d") ("es" :default "Tabla %d") ("fr" :default "Tableau %d :") ("ja" :html "表%d:" :utf-8 "表%d:") ("no" :default "Tabell %d") ("nb" :default "Tabell %d") ("nn" :default "Tabell %d") ("sv" :default "Tabell %d") ("zh-CN" :html "表%d " :utf-8 "表%d ")) ("Table of Contents" ("ca" :html "Índex") ("cs" :default "Obsah") ("da" :default "Indhold") ("de" :default "Inhaltsverzeichnis") ("eo" :default "Enhavo") ("es" :html "Índice") ("fi" :html "Sisällysluettelo") ("fr" :ascii "Sommaire" :default "Table des matières") ("hu" :html "Tartalomjegyzék") ("is" :default "Efnisyfirlit") ("it" :default "Indice") ("ja" :html "目次" :utf-8 "目次") ("nl" :default "Inhoudsopgave") ("no" :default "Innhold") ("nb" :default "Innhold") ("nn" :default "Innhald") ("pl" :html "Spis treści") ("ru" :html "Содержание" :utf-8 "Содержание") ("sv" :html "Innehåll") ("uk" :html "Зміст" :utf-8 "Зміст") ("zh-CN" :html "目录" :utf-8 "目录") ("zh-TW" :html "目錄" :utf-8 "目錄")) ("Unknown reference" ("da" :default "ukendt reference") ("de" :default "Unbekannter Verweis") ("es" :default "referencia desconocida") ("fr" :ascii "Destination inconnue" :default "Référence inconnue") ("zh-CN" :html "未知引用" :utf-8 "未知引用"))) (#$ . 163471))
#@356 Translate string S according to language specification.
ENCODING is a symbol among `:ascii', `:html', `:latex', `:latin1'
and `:utf-8'. INFO is a plist used as a communication channel.
Translation depends on `:language' property. Return the
translated string. If no translation is found, try to fall back
to `:default' encoding. If it fails, return S.
(defalias 'org-export-translate #[(s encoding info) "\306\307\"\310 \310\n \"A\"A \306\f
\"\206 \306\f\311\"\206 \n*\207" [info lang s org-export-dictionary translations encoding plist-get :language assoc :default] 5 (#$ . 170290)])
#@422 Call function FUN on the results returned by BODY evaluation.
FUN is an anonymous function of one argument. BODY evaluation
happens in an asynchronous process, from a buffer which is an
exact copy of the current one.
Use `org-export-add-to-stack' in FUN in order to register results
in the stack.
This is a low level function. See also `org-export-to-buffer'
and `org-export-to-file' for more specialized functions.
(defalias 'org-export-async-start '(macro . #[(fun &rest body) "\306\307!\306\310!\306\311!\306\312!\306\313! \314\315\316\n\317B \320B\321BE\322 \323\324\325\326\327\330\331\332\333\334\nCBD\335\336\337\334
BDD\257CBFDE\340\341 \342B\f\343\344 \345\346\347\350\351\350 \257\nDE\352\353 D\354\fF\316\3559DC\356\f\326\357\360\316\361\362\363\364\365\366\367\370\334 CBDEEEEECBEEFFE-\207" [coding proc-buffer copy-fun temp-file process body make-symbol "--process" "--temp-file" "--copy-fun" "--proc-buffer" "--coding" with-temp-message "Initializing asynchronous export process" let ((org-export--generate-copy-script (current-buffer))) ((make-temp-file "org-export-process")) (buffer-file-coding-system) with-temp-file insert format ";; -*- coding: %s; -*-\n%S" \` with-temp-buffer (when org-export-async-debug '(setq debug-on-error t)) (setq kill-emacs-hook nil org-babel-confirm-evaluate-answer-no t) (require 'ox) funcall \, (restore-buffer-modified-p nil) print progn let* (process-connection-type nil) ((generate-new-buffer-name "*Org Export Process*")) start-process "org-export-process" (expand-file-name invocation-name invocation-directory) "-Q" "--batch" "-l" org-export-async-init-file org-export-add-to-stack get-buffer nil handler set-process-sentinel lambda (p status) ((proc-buffer (process-buffer p))) when (eq (process-status p) 'exit) unwind-protect (if (zerop (process-exit-status p)) (unwind-protect (let ((results (with-current-buffer proc-buffer (goto-char (point-max)) (backward-sexp) (read (current-buffer))))) (funcall (\, handler) results)) (unless org-export-async-debug (and (get-buffer proc-buffer) (kill-buffer proc-buffer)))) (org-export-add-to-stack proc-buffer nil p) (ding) (message "Process `%s' exited abnormally" p)) unless org-export-async-debug delete-file fun] 26 (#$ . 170889)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put org-export-async-start lisp-indent-function 1 put edebug-form-spec t] 4)
#@1232 Call `org-export-as' with output to a specified buffer.
BACKEND is either an export back-end, as returned by, e.g.,
`org-export-create-backend', or a symbol referring to
a registered back-end.
BUFFER is the name of the output buffer. If it already exists,
it will be erased first, otherwise, it will be created.
A non-nil optional argument ASYNC means the process should happen
asynchronously. The resulting buffer should then be accessible
through the `org-export-stack' interface. When ASYNC is nil, the
buffer is displayed if `org-export-show-temporary-export-buffer'
is non-nil.
Optional arguments SUBTREEP, VISIBLE-ONLY, BODY-ONLY and
EXT-PLIST are similar to those used in `org-export-as', which
see.
Optional argument POST-PROCESS is a function which should accept
no argument. It is always called within the current process,
from BUFFER, with point at its beginning. Export back-ends can
use it to set a major mode there, e.g,
(defun org-latex-export-as-latex
(&optional async subtreep visible-only body-only ext-plist)
(interactive)
(org-export-to-buffer \='latex "*Org LATEX Export*"
async subtreep visible-only body-only ext-plist (lambda () (LaTeX-mode))))
This function returns BUFFER.
(defalias 'org-export-to-buffer #[(backend buffer &optional async subtreep visible-only body-only ext-plist post-process) "\203\340 \306\307\310\216\n\203 \311 \312\313\n\"\210\314p!\315\316! @
\317\320\321!! A B\322\216rAq\210\323\324\f\325\326\327\330\331@D\332\333\334\335\336CDDEF\336GD\257DD\257#c\210)rAq\210\337\307\211B\307\340%\210,\307 H\320\341! I\342\316I\343JK\"\344\345\346L\346
& M\347\350I!\307M#\210\351\352\353\317ND\354\355\303\336 DE\356\357\347\360\336CDE\361\331ODD\257E P\362M\351\363\364\365\366\367\370\371\372\370\364\373\331P\374BBE\375BB\376BBB\377\201T \201U
DEEEEE\".\n\207\335CDEFG%\317N! Q N R\201V R!\203\201W \203\201X R!\210rNq\210\201Y \210QRc\210eb\210\201Z O!\203/O \210)S\203<\201[ N!\210N+\207" [async #1=#:current-message #2=#:with-temp-message buffer-file-coding-system #3=#:--coding #4=#:--temp-file "Initializing asynchronous export process" nil #[nil "\205 \203
\302\303 \"\207\302\304!\207" [#2# #1# message #5="%s" nil] 3] current-message message #5# org-export--generate-copy-script make-temp-file "org-export-process" get-buffer-create generate-new-buffer-name " *temp file*" #[nil "\301!\205 \302!\207" [#6=#:temp-buffer buffer-name kill-buffer] 2] format ";; -*- coding: %s; -*-\n%S" with-temp-buffer (when org-export-async-debug '(setq debug-on-error t)) (setq kill-emacs-hook nil org-babel-confirm-evaluate-answer-no t) (require 'ox) funcall (restore-buffer-modified-p nil) print progn org-export-as quote write-region 0 "*Org Export Process*" start-process expand-file-name "-Q" "--batch" "-l" org-export-add-to-stack get-buffer lambda (output) with-current-buffer (erase-buffer) setq (insert output) (goto-char (point-min)) (current-buffer) ignore-errors set-process-sentinel (p status) let ((proc-buffer (process-buffer p))) when (eq (process-status p) 'exit) unwind-protect if (zerop (process-exit-status p)) ((results (with-current-buffer proc-buffer (goto-char (point-max)) (backward-sexp) (read (current-buffer))))) (results) ((unless org-export-async-debug (and (get-buffer proc-buffer) (kill-buffer proc-buffer)))) ((org-export-add-to-stack proc-buffer nil p) (ding) (message "Process `%s' exited abnormally" p)) unless #7=#:--copy-fun #6# #8=#:temp-file backend subtreep visible-only body-only ext-plist process-connection-type #9=#:--proc-buffer invocation-name invocation-directory org-export-async-init-file #10=#:--process buffer post-process handler encoding output org-export-show-temporary-export-buffer org-export-async-debug delete-file org-string-nw-p org-export--copy-to-kill-ring-p org-kill-new erase-buffer functionp switch-to-buffer-other-window] 18 (#$ . 173290)])
(function-put 'org-export-to-buffer 'lisp-indent-function 2)
#@1198 Call `org-export-as' with output to a specified file.
BACKEND is either an export back-end, as returned by, e.g.,
`org-export-create-backend', or a symbol referring to
a registered back-end. FILE is the name of the output file, as
a string.
A non-nil optional argument ASYNC means the process should happen
asynchronously. The resulting buffer will then be accessible
through the `org-export-stack' interface.
Optional arguments SUBTREEP, VISIBLE-ONLY, BODY-ONLY and
EXT-PLIST are similar to those used in `org-export-as', which
see.
Optional argument POST-PROCESS is called with FILE as its
argument and happens asynchronously when ASYNC is non-nil. It
has to return a file name, or nil. Export back-ends can use this
to send the output file through additional processing, e.g,
(defun org-latex-export-to-latex
(&optional async subtreep visible-only body-only ext-plist)
(interactive)
(let ((outfile (org-export-output-file-name ".tex" subtreep)))
(org-export-to-file \='latex outfile
async subtreep visible-only body-only ext-plist
(lambda (file) (org-latex-compile file)))
The function returns either a file name returned by POST-PROCESS,
or FILE.
(defalias 'org-export-to-file #[(backend file &optional async subtreep visible-only body-only ext-plist post-process) "\306!\204\n \307\310!\207\311\312D \"\n\206
\203\313\314 @ A\315\216A\2032 \316 @\317\320A\"\210\321p!\322\323! B C DC\324\325\326!! E F\327\216rEq\210\330\331B\332\333\334\335\336DD\337\340\341\342\343\344\345GDHIJ\345 D\257DC\332\346\342\347\345\fDDC\350DEE\351\352\336\345KDEDEFDD\257#c\210)rEq\210\353\314\211F\314\354%\210,\314 L\325\355! M\356\323M\357NO\"\360\361\362P\362C& Q\363\364M!\314Q#\210\365\366\363\367\345GDEE R\370Q\365\371\342\372\373\374\375\376\377\375\342\201T \336R\201U BBE\201V BB\201W BBB\201X \201Y \201Z CDEEEEE\".\n\202j\344GHIJ % #\201[ \201\\ ! SrSq\210\201] \216#c\210\f '\350!\210,\201^ \203X\201_ #!\203X\201` #!\210\201a K!\203hK!\206i)*\207" [file ext-plist org-export-coding-system buffer-file-coding-system encoding async file-writable-p error "Output file not writable" org-combine-plists :output-file "Initializing asynchronous export process" nil #[nil "\205 \203
\302\303 \"\207\302\304!\207" [#1=#:with-temp-message #2=#:current-message message #3="%s" nil] 3] current-message message #3# org-export--generate-copy-script make-temp-file "org-export-process" get-buffer-create generate-new-buffer-name " *temp file*" #[nil "\301!\205 \302!\207" [#4=#:temp-buffer buffer-name kill-buffer] 2] format ";; -*- coding: %s; -*-\n%S" with-temp-buffer (when org-export-async-debug '(setq debug-on-error t)) (setq kill-emacs-hook nil org-babel-confirm-evaluate-answer-no t) (require 'ox) funcall (restore-buffer-modified-p nil) print progn let output org-export-as quote (insert output) coding-system-for-write write-file or ignore-errors write-region 0 "*Org Export Process*" start-process expand-file-name "-Q" "--batch" "-l" org-export-add-to-stack get-buffer lambda (file) (expand-file-name file) set-process-sentinel (p status) ((proc-buffer (process-buffer p))) when (eq (process-status p) 'exit) unwind-protect if (zerop (process-exit-status p)) #2# #1# #5=#:--coding #6=#:--temp-file #7=#:--copy-fun #4# #8=#:temp-file backend subtreep visible-only body-only post-process process-connection-type #9=#:--proc-buffer invocation-name invocation-directory org-export-async-init-file #10=#:--process handler #11=#:temp-buffer ((results (with-current-buffer proc-buffer (goto-char (point-max)) (backward-sexp) (read (current-buffer))))) (results) ((unless org-export-async-debug (and (get-buffer proc-buffer) (kill-buffer proc-buffer)))) ((org-export-add-to-stack proc-buffer nil p) (ding) (message "Process `%s' exited abnormally" p)) unless org-export-async-debug delete-file generate-new-buffer " *temp*" #[nil "\301!\205 \302!\207" [#11# buffer-name kill-buffer] 2] org-export--copy-to-kill-ring-p org-string-nw-p org-kill-new functionp] 20 (#$ . 177299)])
(function-put 'org-export-to-file 'lisp-indent-function 2)
#@490 Return output file's name according to buffer specifications.
EXTENSION is a string representing the output file extension,
with the leading dot.
With a non-nil optional argument SUBTREEP, try to determine
output file's name by looking for "EXPORT_FILE_NAME" property
of subtree at point.
When optional argument PUB-DIR is set, use it as the publishing
directory.
When optional argument VISIBLE-ONLY is non-nil, don't export
contents of hidden elements.
Return file name as a string.
(defalias 'org-export-output-file-name #[(extension &optional subtreep pub-dir) "\306\307 !\310 \203! \311\212\3121 \313 \210`0\202 \210\314)\315\316#\206; \203+ \317!\206; \n\2050 \320\321\322\f\314\211\211\323&)! \f\203M \324\f!\317
!Q\202a \325
!\203Z
P\202a \324\326!
Q \203w \327\"\203w P\202y +\207" [visited-file subtreep org-completion-use-ido read-file-name-function pub-dir base-name buffer-file-name buffer-base-buffer file-name-sans-extension org-entry-get (error) org-back-to-heading nil "EXPORT_FILE_NAME" t file-name-nondirectory ido-read-file-name read-file-name "Output file: " #[(name) "\302\303\" \230\207" [name extension file-name-extension t] 3] file-name-as-directory file-name-absolute-p "." org-file-equal-p extension output-file] 8 (#$ . 181448)])
#@297 Add a new result to export stack if not present already.
SOURCE is a buffer or a file name containing export results.
BACKEND is a symbol representing export back-end used to generate
it.
Entries already pointing to SOURCE and unavailable entries are
removed beforehand. Return the new stack.
(defalias 'org-export-add-to-stack #[(source backend &optional process) " \n\206 \304 E\305!B\211\207" [source backend process org-export-stack-contents current-time org-export-stack-remove] 3 (#$ . 182744)])
#@61 Menu for asynchronous export results and running processes.
(defalias 'org-export-stack #[nil "\301\302!\211q\210\303 \304U\203 \305 \210\306 \210\307!\210)\310\311!\207" [buffer get-buffer-create "*Org Export Stack*" buffer-size 0 org-export-stack-mode org-export-stack-refresh pop-to-buffer message "Type \"q\" to quit, \"?\" for help"] 3 (#$ . 183259) nil])
#@54 Return source from export results at point in stack.
(defalias 'org-export--stack-source-at-point #[nil "\304\212\203\n b\210n\203 \305\202 \306\307\305`\"\\*S 8@\211\204( \310\311!\202M \n;\2031 \n\2024 \312\n!\212\313 \210\314\315\316 !\317Q!)\203I \n\202L \310\320!))\207" [pos org-export-stack-contents source source-name nil 1 0 count-lines error "Source unavailable, please refresh buffer" buffer-name beginning-of-line looking-at ".* +" regexp-quote "$" "Source unavailable; type `g' to update buffer"] 5 (#$ . 183629)])
#@39 Remove all entries from export stack.
(defalias 'org-export-stack-clear #[nil "\301\211\207" [org-export-stack-contents nil] 2 (#$ . 184170) nil])
#@128 Refresh the asynchronous export stack.
DUMMY is ignored. Unavailable sources are removed from the list.
Return the new stack.
(defalias 'org-export-stack-refresh #[(&rest dummy) "\306\307\212 \203\f b\210n\203 \310\202 \311\312\310`\"\\*i\313\216\314 \210\311 \315\316\317\320
\"\211\321#)\260c,\207" [inhibit-read-only pos #1=#:--col #2=#:--line counter org-export-stack-contents t nil 1 0 count-lines #[nil "\214~\210eb\210 Sy*\210\303\n!\207" [#2# N #1# org-move-to-column] 2] erase-buffer mapconcat #[(entry) "\304\3058!\306\307A@\206 \310\"\3058 \203! \306\311\312\n!\"\202) \313\314\315\316\n!!\")\306\317@\211;\2038 \202; \320 !)\"Q)\207" [entry proc-p data source processp 2 format " %-12s " "" " %6s " process-status org-format-seconds "%4h:%.2m " float-time time-since " %s" buffer-name] 7] org-remove-if-not #[(el) "\302\3038!\203 \304\305\3038!!\207@\306 !\203 \304 !\202\" \307 !)\207" [el source processp 2 buffer-live-p process-buffer bufferp file-exists-p] 4] "\n"] 5 (#$ . 184325)])
#@103 Remove export results at point from stack.
If optional argument SOURCE is non-nil, remove it instead.
(defalias 'org-export-stack-remove #[(&optional source) "\206 \302 \303\304 \"\211)\207" [source org-export-stack-contents org-export--stack-source-at-point org-remove-if #[(el) "@ \232\207" [el source] 2]] 3 (#$ . 185362) nil])
#@117 View export results at point in stack.
With an optional prefix argument IN-EMACS, force viewing files
within Emacs.
(defalias 'org-export-stack-view #[(&optional in-emacs) "\302 \303!\203 \304\305!!\202! \306!\203 \304!\202! \307 \")\207" [source in-emacs org-export--stack-source-at-point processp org-switch-to-buffer-other-window process-buffer bufferp org-open-file] 3 (#$ . 185705) "P"])
#@30 Keymap for Org Export Stack.
(defvar org-export-stack-mode-map (byte-code "\301 \302\303\304#\210\302\305\304#\210\302\306\304#\210\302\307\304#\210\302\310\311#\210\302\312\311#\210\302\313\311#\210\302\314\311#\210\302\315\316#\210\302\317\320#\210\302\321\320#\210\302\322\323#\210)\207" [km make-sparse-keymap define-key " " next-line "n" "" [down] "p" previous-line "" "" [up] "C" org-export-stack-clear "v" org-export-stack-view "
" "d" org-export-stack-remove] 4) (#$ . 186112))
#@166 Hook run after entering Org-Stack mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar org-export-stack-mode-hook nil (#$ . 186622))
(byte-code "\300\301!\204\f \302\301\303\304#\210\300\207" [boundp org-export-stack-mode-map put definition-name org-export-stack-mode] 4)
(defvar org-export-stack-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [org-export-stack-mode-map variable-documentation put purecopy "Keymap for `org-export-stack-mode'." boundp org-export-stack-mode-syntax-table definition-name org-export-stack-mode] 5)
(defvar org-export-stack-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [org-export-stack-mode-syntax-table variable-documentation put purecopy "Syntax table for `org-export-stack-mode'." org-export-stack-mode-abbrev-table definition-name org-export-stack-mode] 5)
(defvar org-export-stack-mode-abbrev-table (progn (define-abbrev-table 'org-export-stack-mode-abbrev-table nil) org-export-stack-mode-abbrev-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [org-export-stack-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `org-export-stack-mode'." org-export-stack-mode derived-mode-parent special-mode] 5)
#@655 Mode for displaying asynchronous export stack.
Type \[org-export-stack] to visualize the asynchronous export
stack.
In an Org Export Stack buffer, use \<org-export-stack-mode-map>\[org-export-stack-view] to view export output
on current line, \[org-export-stack-remove] to remove it from the stack and \[org-export-stack-clear] to clear
stack completely.
Removing entries in an Org Export Stack buffer doesn't affect
files or buffers, only the display.
\{org-export-stack-mode-map}
In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `org-export-stack-mode-hook', as the final step
during initialization.
(defalias 'org-export-stack-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315 !\204' \316 \317 \"\210\320\f!\211 \2036
\321 =\203< \322\f\323 \"\210)\324$\325\"\204V $%=\204V \326$\325%C#\210\327 !\210\330\f!\210$%\331\332!\210\333\332!\210\307\211&'\307(\334)\335\336\337\340\307$\210\306\341!\210\337!)\342\343!\207" [delay-mode-hooks major-mode mode-name org-export-stack-mode-map org-export-stack-mode-syntax-table parent make-local-variable t special-mode org-export-stack-mode "Org-Stack" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table abbrev-mode 0 auto-fill-mode (:eval (format " %-12s | %6s | %s" "Back-End" "Age" "Source")) org-add-hook post-command-hook org-export-stack-refresh nil revert-buffer-function run-mode-hooks org-export-stack-mode-hook org-export-stack-mode-abbrev-table local-abbrev-table buffer-read-only buffer-undo-list truncate-lines header-line-format] 6 (#$ . 188060) nil])
#@698 Export dispatcher for Org mode.
It provides an access to common export related tasks in a buffer.
Its interface comes in two flavors: standard and expert.
While both share the same set of bindings, only the former
displays the valid keys associations in a dedicated buffer.
Scrolling (resp. line-wise motion) in this buffer is done with
SPC and DEL (resp. C-n and C-p) keys.
Set variable `org-export-dispatch-use-expert-ui' to switch to one
flavor or the other.
When ARG is \[universal-argument], repeat the last export action, with the same set
of options used back then, on the current buffer.
When ARG is \[universal-argument] \[universal-argument], display the asynchronous export stack.
(defalias 'org-export-dispatch #[(&optional arg) "\306\232\203\n \307\202/ \203 \206/ \310 \311\216\312\216 `\313p!\223\210\314\f
\205' \315D\316%#\211+\211 &@ '&A (\317(>\204F \316\211\223\210\320'\321\"\203V \322\316(\"\202 \320'\323\"\203c \324 \202 \320'\325\"\203x \326\327(>\315(>\"\202 \320'\330\"\203\215 \331\327(>\315(>\"\202 \320'\332\"\203\255 \333\334\335\336)\316\337$)\"\327(>\315(>#\202 \320'\340\"\203\302 \341\327(>\315(>\"\202 \212\203\334 \342 !\313p!=\203\327 b\210\202\334 \316\211\223\210'\315(>\205\346 \337\317(>\205\356 \337\343(>\205\366 \337\344(>\205\376 \337$)+\207" [arg org-export-dispatch-last-action #1=#:wconfig org-export-dispatch-last-position org-export-initial-scope org-export-in-background (16) (stack) current-window-configuration #[nil "\301!\207" [#1# set-window-configuration] 2] #[nil "\300\301!\205 \302\301!\207" [get-buffer "*Org Export Dispatcher*" kill-buffer] 2] org-base-buffer org-export--dispatch-ui async nil subtree eql template org-export-insert-default-template stack org-export-stack publish-current-file org-publish-current-file force publish-current-project org-publish-current-project publish-choose-project org-publish assoc org-icompleting-read "Publish project: " t publish-all org-publish-all marker-buffer visible body org-export-dispatch-use-expert-ui input action optns org-publish-project-alist] 8 (#$ . 189851) "P"])
#@711 Handle interface for `org-export-dispatch'.
OPTIONS is a list containing current interactive options set for
export. It can contain any of the following symbols:
`body' toggles a body-only export
`subtree' restricts export to current subtree
`visible' restricts export to visible part of buffer.
`force' force publishing files.
`async' use asynchronous export process
FIRST-KEY is the key pressed to select the first level menu. It
is nil when this menu hasn't been selected yet.
EXPERTP, when non-nil, triggers expert UI. In that case, no help
buffer is provided, but indications about currently active
options are given in the prompt. Moreover, [?] allows switching
back to standard interface.
(defalias 'org-export--dispatch-ui #[(options first-key expertp) "\306\307\310\211\311\312\313\314\n\"\"\315\"\316\"\317\320\321\322\323\257\f\204/ \313\324 \" \325
! @\326@!*\202g \312 A \312 B\211 C\203[ C@\211B@\f=\203R \327\317B8A\"ACA\211C\204< \312B\310\313\324A\"\330\"+\244\f\331=\203v \332\333\334\335F\202} \f?\205} \331C\244\336\337D\244D\205\211 \340C\244\341C\244 ED?\2056\342\343\344\345\" \346F>\203\247 \347\202\250 \350!\351\345\" \352F>\203\271 \347\202\272 \350!\353\345\" \354F>\203\313 \355\202\314 \356!\357\345\" \360F>\203\335 \347\202\336 \350!\361\345\" \362F>\203\357 \347\202\360 \350!& \312 G\363\364 \365#)\342\366\367!\370\331\"\371\331\"\372\331\"\373\331\"&\342\374\375\345\"\376\345\"#\342\377\201N \345\"\f\2030\201O \2023\201P #\260 HD?\205A\201Q ID\205\255\342\201R \346F>\203\\\201S \345\"\202_\201S \352F>\203o\201T \345\"\202r\201T \354F>\203\202\201U \345\"\202\205\201U \360F>\203\223\370\345\"\202\224\370\362F>\203\242\373\345\"\202\243\373\363\201V E\365#& JD\203\306\201W JE F\fD&\202/\201X \201Y !\204\375\201Z \210\201[ \201\\ \201Y !!\210\312K\201] L\201^ \201_ !\210\201` \201a \201b \"\210r\201Y q\210\201c M\201d \210Hc\210\201e \312M\"\210*\201f \210\201W IE F\fD&.\207" [fontify-key fontify-value org-export--registered-backends entries first-key list #[(key &optional access-key) "\303=\204\f =\203 \304\n\305\306#\207\n\207" [access-key first-key key t org-propertize face org-warning] 4] #[(value) "\301\302\303#\207" [value org-propertize face font-lock-variable-name-face] 4] sort delq nil mapcar org-export-backend-menu #[(a b) "A@ A@\211\247\203 \n\247\203 \nW\202 \n\247\205 \304*\207" [a b key-b key-a t] 3] car-less-than-car 2 22 19 6 1 car copy-sequence delete-dups append < 80 102 112 120 97 38 35 63 113 format "[%s] Body only: %s [%s] Visible only: %s\n[%s] Export scope: %s [%s] Force publishing: %s\n[%s] Async export: %s\n\n" "C-b" t body "On " "Off" "C-v" visible "C-s" subtree "Subtree" "Buffer " "C-f" force "C-a" async mapconcat #[(entry) "@\211\n=?\205 \306\307 \310 !!A@#\3118 \312\f!?\2055 \313 \314\315\f\316#\317
\311\"\320U\2053 \321P))P)\207" [entry top-key last-key fontify-key sub-menu index format "\n[%s] %s\n" char-to-string 2 functionp -1 mapconcat #[(sub-entry) "T\304\305\306\"\307U\203 \310\202 \311 \312\n@! \"\nA@#\207" [index fontify-key sub-entry top-key format mod 2 0 " [%s] %-26s" "[%s] %s\n" char-to-string] 5] #1="" mod 0 "\n"] 6] #1# "\n[%s] Publish\n [%s] Current file [%s] Current project\n [%s] Choose project [%s] All projects\n\n\n" "P" "f" "p" "x" "a" "[%s] Export stack [%s] Insert template\n" "&" "#" "[%s] %s" res sub-menu entry --dolist-tail-- expertp allowed-keys options last-key help standard-prompt expert-prompt cursor-type header-line-format pos "q" "Main menu" "Exit" "Export command: " "Export command (C-%s%s%s%s%s) [%s]: " "b" "v" "s" #[(k) "\301W?\205\n \302!\207" [k 27 char-to-string] 2] org-export--dispatch-action get-buffer "*Org Export Dispatcher*" delete-other-windows org-switch-to-buffer-other-window get-buffer-create "Use SPC, DEL, C-n or C-p to navigate." set-syntax-table copy-syntax-table modify-syntax-entry 91 "w" window-start erase-buffer set-window-start org-fit-window-to-buffer] 15 (#$ . 191987)])
#@457 Read a character from command input and act accordingly.
PROMPT is the displayed prompt, as a string. ALLOWED-KEYS is
a list of characters available at a given step in the process.
ENTRIES is a list of menu entries. OPTIONS, FIRST-KEY and
EXPERTP are the same as defined in `org-export--dispatch-ui',
which see.
Toggle export options when required. Otherwise, return value is
a list with action as CAR and a list of interactive export
options as CDR.
(defalias 'org-export--dispatch-action #[(prompt allowed-keys entries options first-key expertp) "\306\307 !\211\203\250 \n\204\250 \310>\203\250 \311\312\"\203? \313d!\2044 \3141, \315\316!0\2020 \210\202 \210\202 \317\320!\210\321\316!\210\202 \311\322\"\203j \313e!\204_ \3231W \324\316!0\202[ \210\202 \210\202 \317\325!\210\321\316!\210\202 \311\326\"\203\211 \313d!\204~ \315\306!\210\202 \317\320!\210\321\316!\210\202 \311\327\"\203 \313e!\204\235 \324\306!\210\202 \317\325!\210\321\316!\210\202 >\204\305 \330 \210\n\204\275 \317\331!\210\321\316!\210\332\f
\n#\202\300\333=\203\335
\204\325 \334\335!\202\300\332\f\306\n#\202\300\336=\203\353 \332\f
\306#\202\300\337=\203\371 \340\341\f>B\202\300\342=\203\343\202\300\344>\203Y\332\311\345\"\203\346\202>\311\347\"\203 \350\202>\311\351\"\203+\341\202>\311\352\"\2036\353\202>\311\316\"\205>\354\211 ;\f>\203N\355;\f\"\202R;\fB)
\n#\202\300
\204h\356\345<\2368!\203\273
\204u\345<\2368\202\266
\357=\203\247\311\360\"\203\206\361\202\266\311\362\"\203\221\363\202\266\311\364\"\203\234\365\202\266\311\366\"\205\266\367\202\266\3702\266\371\372
<\236<\235\"0\fB\202\300\332\f\n#)\207" [key prompt expertp allowed-keys options first-key nil read-char-exclusive (14 16 32 127) eql 14 pos-visible-in-window-p (error) scroll-up 1 message "End of buffer" sit-for 16 (error) scroll-down "Beginning of buffer" 32 127 ding "Invalid key" org-export--dispatch-ui 113 error "Export aborted" 63 35 template subtree 38 (stack) (2 22 19 6 1) 2 body 22 visible 19 6 force async remq functionp 80 102 publish-current-file 112 publish-current-project 120 publish-choose-project 97 publish-all found mapc #[(entry) "\303 8\236\211\205 \304\305\303\n8\")\207" [key entry match 2 throw found] 5] option entries] 5 (#$ . 196135)])
(provide 'ox)
Kontol Shell Bypass