├── .gitattributes
├── .gitignore
├── .gitmodules
├── .luarc.json
├── LICENSE
├── Makefile
├── README.md
├── TODO.md
├── docs
    ├── .gitignore
    ├── 404.html
    ├── Gemfile
    ├── Gemfile.lock
    ├── _config.yml
    ├── _data
    │   └── menu.yml
    ├── _includes
    │   ├── header.html
    │   └── repo.html
    ├── img
    │   ├── thm-spivak-html-docx.png
    │   └── thm-spivak.png
    ├── index.md
    ├── manual.md
    └── tour.md
├── extras
    ├── layouttranslations
    └── parser.lua
├── src
    ├── Crossref.aggregate_references.lua
    ├── Crossref.collect_identifiers.lua
    ├── Crossref.get_pre_mode.lua
    ├── Crossref.lua
    ├── Crossref.parse_Cite.lua
    ├── Crossref.parse_Link.lua
    ├── Crossref.parse_identifier.lua
    ├── Crossref.parse_target.lua
    ├── Crossref.process.lua
    ├── Crossref.register_identifier.lua
    ├── Crossref.write.lua
    ├── Helpers.font_format.lua
    ├── Helpers.font_format_native.lua
    ├── Helpers.length_format.lua
    ├── Setup.DEFAULTS.lua
    ├── Setup.LOCALE.lua
    ├── Setup.create_aliases.lua
    ├── Setup.create_counters.lua
    ├── Setup.create_kinds_and_styles.lua
    ├── Setup.create_kinds_and_styles_defaults.lua
    ├── Setup.create_kinds_and_styles_user.lua
    ├── Setup.font_format.lua
    ├── Setup.increment_counter.lua
    ├── Setup.length_format.lua
    ├── Setup.read_options.lua
    ├── Setup.set_kind.lua
    ├── Setup.set_style.lua
    ├── Setup.update_meta.lua
    ├── Setup.validate_defaults.lua
    ├── Setup.write_counter.lua
    ├── Statement.DefListitem_is_statement.lua
    ├── Statement.Div_is_statement.lua
    ├── Statement.extract_fbb.lua
    ├── Statement.is_kind_key.lua
    ├── Statement.is_statement.lua
    ├── Statement.lua
    ├── Statement.new_kind_from_label.lua
    ├── Statement.new_kind_unnumbered.lua
    ├── Statement.parse_DefList.lua
    ├── Statement.parse_DefList_kind.lua
    ├── Statement.parse_Div.lua
    ├── Statement.parse_heading_inlines.lua
    ├── Statement.parse_identifier.lua
    ├── Statement.set_count.lua
    ├── Statement.set_identifier.lua
    ├── Statement.set_is_numbered.lua
    ├── Statement.set_labels.lua
    ├── Statement.set_values.lua
    ├── Statement.trim_dot_space.lua
    ├── Statement.write.lua
    ├── Statement.write_html.lua
    ├── Statement.write_jats.lua
    ├── Statement.write_kind.lua
    ├── Statement.write_label.lua
    ├── Statement.write_latex.lua
    ├── Statement.write_native.lua
    ├── Statement.write_style.lua
    ├── Walker.crossreferences.lua
    ├── Walker.lua
    ├── Walker.statements_in_lists.lua
    ├── Walker.walk.lua
    ├── helpers.lua
    ├── main.lua
    └── setup.lua
├── statement.lua
└── tests
    ├── AMSthm-test-file-swap-numbers.md
    ├── AMSthm-test-file.md
    ├── Linebreak_theorem_style.md
    ├── Lists_in_theorems.md
    ├── Makefile
    ├── aliases.md
    ├── automatic_locale.md
    ├── benchmark_pandoc-amsthm.md
    ├── benchmark_pandoc-theorem.md
    ├── cross-references.md
    ├── define_kinds_by_style.md
    ├── documentation_examples.md
    ├── number_offset.md
    ├── principles_vignettes.md
    ├── recursion_and_lists.md
    ├── styles_based_on_styles.md
    ├── styles_customize.md
    ├── syntax_definition_lists.md
    └── syntax_fenced_div.md


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Temporary MS Word and Libreoffice files
2 | ~$*.docx
3 | .*.odt#
4 | *.pdf
5 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "lua-builder"]
2 | 	path = lua-builder
3 | 	url = https://github.com/jdutant/lua-builder
4 | 


--------------------------------------------------------------------------------
/.luarc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "Generator": [
 3 |     "Quarto",
 4 |     "This file provides type information for Lua completion and diagnostics.",
 5 |     "Quarto will automatically update this file to reflect the current path",
 6 |     "of your Quarto installation, and the file will also be added to .gitignore",
 7 |     "since it points to the absolute path of Quarto on the local system.",
 8 |     "Remove the 'Generator' key to manage this file's contents manually."
 9 |   ],
10 |   "Lua.runtime.version": "Lua 5.3",
11 |   "Lua.workspace.checkThirdParty": false,
12 |   "Lua.workspace.library": [
13 |     "/Applications/quarto/share/lua-types"
14 |   ],
15 |   "Lua.runtime.plugin": "/Applications/quarto/share/lua-plugin/plugin.lua",
16 |   "Lua.completion.showWord": "Disable",
17 |   "Lua.completion.keywordSnippet": "Both",
18 |   "Lua.diagnostics.disable": [
19 |     "lowercase-global",
20 |     "trailing-space"
21 |   ]
22 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Julien Dutant, Thomas Hodgson
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | DIFF ?= diff --strip-trailing-cr -u
 2 | INFO = quiet # use make INFO=verbose to get Pandoc verbose output
 3 | SRC_FILES = $(wildcard src/*.lua)
 4 | 
 5 | .PHONY: statement.lua
 6 | 
 7 | statement.lua: $(SRC_FILES) lua-builder/lua-builder.lua
 8 | 	@lua lua-builder/lua-builder.lua src/main.lua -o statement.lua --verbose --recursive
 9 | 
10 | 


--------------------------------------------------------------------------------
/TODO.md:
--------------------------------------------------------------------------------
 1 | * bug: statement in lists hide the heading. Perhaps use a
 2 |   statement-span? the trick is that the minipage wrapping must be
 3 |   done before statement processing, but leave the header visible to
 4 |   the statement parser
 5 | * clarify code: take trim_dot_space in Helpers
 6 | * parse-only mode? Find statements and write crossrefs, but do not
 7 |   write statements themselves. Collection filter: needs to amend
 8 |   Cites that refer to statements; for that it needs all the statement
 9 |   IDs, sort out the Cites into crossref vs biblio.
10 | * provide styling of crossref label, esp. smallcaps for statement
11 | * provide head-pattern, '<label> <num>. **<info>**', relying on
12 |   Pandoc's rawinline parsing
13 | * provide \ref \label crossreferences in LaTeX?
14 | * handle pandoc-amsthm style Div attributes?
15 | * handle the Case environment?
16 | * use DefinitionLists for generic output?
17 | * proof environment in non-LaTeX outputs in LaTeX AMS the proof envt
18 |   doesn't define a new th kind and style as a proofname command to be
19 |   redefined as "Proof", "Démonstration" etc. has an optional argument
20 |   to be used as label: \begin{proof}[label] \end{proof} In other
21 |   formats, we should mirror LaTeX: use the info as label
22 | 


--------------------------------------------------------------------------------
/docs/.gitignore:
--------------------------------------------------------------------------------
1 | _site
2 | .sass-cache
3 | .jekyll-cache
4 | .jekyll-metadata
5 | vendor
6 | 


--------------------------------------------------------------------------------
/docs/404.html:
--------------------------------------------------------------------------------
 1 | ---
 2 | permalink: /404.html
 3 | layout: default
 4 | ---
 5 | 
 6 | <style type="text/css" media="screen">
 7 |   .container {
 8 |     margin: 10px auto;
 9 |     max-width: 600px;
10 |     text-align: center;
11 |   }
12 |   h1 {
13 |     margin: 30px 0;
14 |     font-size: 4em;
15 |     line-height: 1;
16 |     letter-spacing: -1px;
17 |   }
18 | </style>
19 | 
20 | <div class="container">
21 |   <h1>404</h1>
22 | 
23 |   <p><strong>Page not found :(</strong></p>
24 |   <p>The requested page could not be found.</p>
25 | </div>
26 | 


--------------------------------------------------------------------------------
/docs/Gemfile:
--------------------------------------------------------------------------------
 1 | source "https://rubygems.org"
 2 | # Hello! This is where you manage which Jekyll version is used to run.
 3 | # When you want to use a different version, change it below, save the
 4 | # file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
 5 | #
 6 | #     bundle exec jekyll serve
 7 | #
 8 | # This will help ensure the proper Jekyll version is running.
 9 | # Happy Jekylling!
10 | # gem "jekyll", "~> 4.3.1"
11 | # This is the default theme for new Jekyll sites. You may change this to anything you like.
12 | gem "minima", "= 2.5.1"
13 | #gem "jekyll-theme-minimal", "= 0.2.0"
14 | # gem "just-the-docs", "~> 0.3.3"
15 | # If you want to use GitHub Pages, remove the "gem "jekyll"" above and
16 | # uncomment the line below. To upgrade, run `bundle update github-pages`.
17 | gem "github-pages", "~> 227", group: :jekyll_plugins
18 | # If you have any plugins, put them here!
19 | #group :jekyll_plugins do
20 | #  gem "jekyll-feed", "~> 0.12"
21 | #end
22 | 
23 | # Windows and JRuby does not include zoneinfo files, so bundle the tzinfo-data gem
24 | # and associated library.
25 | platforms :mingw, :x64_mingw, :mswin, :jruby do
26 |   gem "tzinfo", ">= 1", "< 3"
27 |   gem "tzinfo-data"
28 | end
29 | 
30 | # Performance-booster for watching directories on Windows
31 | gem "wdm", "~> 0.1.1", :platforms => [:mingw, :x64_mingw, :mswin]
32 | 
33 | # Lock `http_parser.rb` gem to `v0.6.x` on JRuby builds since newer versions of the gem
34 | # do not have a Java counterpart.
35 | gem "http_parser.rb", "~> 0.6.0", :platforms => [:jruby]
36 | 
37 | # Jekyll needs webrick since Ruby 3.0 (https://github.com/jekyll/jekyll/issues/8523)
38 | gem "webrick", '>=1.7.0'


--------------------------------------------------------------------------------
/docs/Gemfile.lock:
--------------------------------------------------------------------------------
  1 | GEM
  2 |   remote: https://rubygems.org/
  3 |   specs:
  4 |     activesupport (6.0.6)
  5 |       concurrent-ruby (~> 1.0, >= 1.0.2)
  6 |       i18n (>= 0.7, < 2)
  7 |       minitest (~> 5.1)
  8 |       tzinfo (~> 1.1)
  9 |       zeitwerk (~> 2.2, >= 2.2.2)
 10 |     addressable (2.8.1)
 11 |       public_suffix (>= 2.0.2, < 6.0)
 12 |     coffee-script (2.4.1)
 13 |       coffee-script-source
 14 |       execjs
 15 |     coffee-script-source (1.11.1)
 16 |     colorator (1.1.0)
 17 |     commonmarker (0.23.6)
 18 |     concurrent-ruby (1.1.10)
 19 |     dnsruby (1.61.9)
 20 |       simpleidn (~> 0.1)
 21 |     em-websocket (0.5.3)
 22 |       eventmachine (>= 0.12.9)
 23 |       http_parser.rb (~> 0)
 24 |     ethon (0.16.0)
 25 |       ffi (>= 1.15.0)
 26 |     eventmachine (1.2.7)
 27 |     execjs (2.8.1)
 28 |     faraday (2.6.0)
 29 |       faraday-net_http (>= 2.0, < 3.1)
 30 |       ruby2_keywords (>= 0.0.4)
 31 |     faraday-net_http (3.0.1)
 32 |     ffi (1.15.5)
 33 |     forwardable-extended (2.6.0)
 34 |     gemoji (3.0.1)
 35 |     github-pages (227)
 36 |       github-pages-health-check (= 1.17.9)
 37 |       jekyll (= 3.9.2)
 38 |       jekyll-avatar (= 0.7.0)
 39 |       jekyll-coffeescript (= 1.1.1)
 40 |       jekyll-commonmark-ghpages (= 0.2.0)
 41 |       jekyll-default-layout (= 0.1.4)
 42 |       jekyll-feed (= 0.15.1)
 43 |       jekyll-gist (= 1.5.0)
 44 |       jekyll-github-metadata (= 2.13.0)
 45 |       jekyll-include-cache (= 0.2.1)
 46 |       jekyll-mentions (= 1.6.0)
 47 |       jekyll-optional-front-matter (= 0.3.2)
 48 |       jekyll-paginate (= 1.1.0)
 49 |       jekyll-readme-index (= 0.3.0)
 50 |       jekyll-redirect-from (= 0.16.0)
 51 |       jekyll-relative-links (= 0.6.1)
 52 |       jekyll-remote-theme (= 0.4.3)
 53 |       jekyll-sass-converter (= 1.5.2)
 54 |       jekyll-seo-tag (= 2.8.0)
 55 |       jekyll-sitemap (= 1.4.0)
 56 |       jekyll-swiss (= 1.0.0)
 57 |       jekyll-theme-architect (= 0.2.0)
 58 |       jekyll-theme-cayman (= 0.2.0)
 59 |       jekyll-theme-dinky (= 0.2.0)
 60 |       jekyll-theme-hacker (= 0.2.0)
 61 |       jekyll-theme-leap-day (= 0.2.0)
 62 |       jekyll-theme-merlot (= 0.2.0)
 63 |       jekyll-theme-midnight (= 0.2.0)
 64 |       jekyll-theme-minimal (= 0.2.0)
 65 |       jekyll-theme-modernist (= 0.2.0)
 66 |       jekyll-theme-primer (= 0.6.0)
 67 |       jekyll-theme-slate (= 0.2.0)
 68 |       jekyll-theme-tactile (= 0.2.0)
 69 |       jekyll-theme-time-machine (= 0.2.0)
 70 |       jekyll-titles-from-headings (= 0.5.3)
 71 |       jemoji (= 0.12.0)
 72 |       kramdown (= 2.3.2)
 73 |       kramdown-parser-gfm (= 1.1.0)
 74 |       liquid (= 4.0.3)
 75 |       mercenary (~> 0.3)
 76 |       minima (= 2.5.1)
 77 |       nokogiri (>= 1.13.6, < 2.0)
 78 |       rouge (= 3.26.0)
 79 |       terminal-table (~> 1.4)
 80 |     github-pages-health-check (1.17.9)
 81 |       addressable (~> 2.3)
 82 |       dnsruby (~> 1.60)
 83 |       octokit (~> 4.0)
 84 |       public_suffix (>= 3.0, < 5.0)
 85 |       typhoeus (~> 1.3)
 86 |     html-pipeline (2.14.3)
 87 |       activesupport (>= 2)
 88 |       nokogiri (>= 1.4)
 89 |     http_parser.rb (0.8.0)
 90 |     i18n (0.9.5)
 91 |       concurrent-ruby (~> 1.0)
 92 |     jekyll (3.9.2)
 93 |       addressable (~> 2.4)
 94 |       colorator (~> 1.0)
 95 |       em-websocket (~> 0.5)
 96 |       i18n (~> 0.7)
 97 |       jekyll-sass-converter (~> 1.0)
 98 |       jekyll-watch (~> 2.0)
 99 |       kramdown (>= 1.17, < 3)
100 |       liquid (~> 4.0)
101 |       mercenary (~> 0.3.3)
102 |       pathutil (~> 0.9)
103 |       rouge (>= 1.7, < 4)
104 |       safe_yaml (~> 1.0)
105 |     jekyll-avatar (0.7.0)
106 |       jekyll (>= 3.0, < 5.0)
107 |     jekyll-coffeescript (1.1.1)
108 |       coffee-script (~> 2.2)
109 |       coffee-script-source (~> 1.11.1)
110 |     jekyll-commonmark (1.4.0)
111 |       commonmarker (~> 0.22)
112 |     jekyll-commonmark-ghpages (0.2.0)
113 |       commonmarker (~> 0.23.4)
114 |       jekyll (~> 3.9.0)
115 |       jekyll-commonmark (~> 1.4.0)
116 |       rouge (>= 2.0, < 4.0)
117 |     jekyll-default-layout (0.1.4)
118 |       jekyll (~> 3.0)
119 |     jekyll-feed (0.15.1)
120 |       jekyll (>= 3.7, < 5.0)
121 |     jekyll-gist (1.5.0)
122 |       octokit (~> 4.2)
123 |     jekyll-github-metadata (2.13.0)
124 |       jekyll (>= 3.4, < 5.0)
125 |       octokit (~> 4.0, != 4.4.0)
126 |     jekyll-include-cache (0.2.1)
127 |       jekyll (>= 3.7, < 5.0)
128 |     jekyll-mentions (1.6.0)
129 |       html-pipeline (~> 2.3)
130 |       jekyll (>= 3.7, < 5.0)
131 |     jekyll-optional-front-matter (0.3.2)
132 |       jekyll (>= 3.0, < 5.0)
133 |     jekyll-paginate (1.1.0)
134 |     jekyll-readme-index (0.3.0)
135 |       jekyll (>= 3.0, < 5.0)
136 |     jekyll-redirect-from (0.16.0)
137 |       jekyll (>= 3.3, < 5.0)
138 |     jekyll-relative-links (0.6.1)
139 |       jekyll (>= 3.3, < 5.0)
140 |     jekyll-remote-theme (0.4.3)
141 |       addressable (~> 2.0)
142 |       jekyll (>= 3.5, < 5.0)
143 |       jekyll-sass-converter (>= 1.0, <= 3.0.0, != 2.0.0)
144 |       rubyzip (>= 1.3.0, < 3.0)
145 |     jekyll-sass-converter (1.5.2)
146 |       sass (~> 3.4)
147 |     jekyll-seo-tag (2.8.0)
148 |       jekyll (>= 3.8, < 5.0)
149 |     jekyll-sitemap (1.4.0)
150 |       jekyll (>= 3.7, < 5.0)
151 |     jekyll-swiss (1.0.0)
152 |     jekyll-theme-architect (0.2.0)
153 |       jekyll (> 3.5, < 5.0)
154 |       jekyll-seo-tag (~> 2.0)
155 |     jekyll-theme-cayman (0.2.0)
156 |       jekyll (> 3.5, < 5.0)
157 |       jekyll-seo-tag (~> 2.0)
158 |     jekyll-theme-dinky (0.2.0)
159 |       jekyll (> 3.5, < 5.0)
160 |       jekyll-seo-tag (~> 2.0)
161 |     jekyll-theme-hacker (0.2.0)
162 |       jekyll (> 3.5, < 5.0)
163 |       jekyll-seo-tag (~> 2.0)
164 |     jekyll-theme-leap-day (0.2.0)
165 |       jekyll (> 3.5, < 5.0)
166 |       jekyll-seo-tag (~> 2.0)
167 |     jekyll-theme-merlot (0.2.0)
168 |       jekyll (> 3.5, < 5.0)
169 |       jekyll-seo-tag (~> 2.0)
170 |     jekyll-theme-midnight (0.2.0)
171 |       jekyll (> 3.5, < 5.0)
172 |       jekyll-seo-tag (~> 2.0)
173 |     jekyll-theme-minimal (0.2.0)
174 |       jekyll (> 3.5, < 5.0)
175 |       jekyll-seo-tag (~> 2.0)
176 |     jekyll-theme-modernist (0.2.0)
177 |       jekyll (> 3.5, < 5.0)
178 |       jekyll-seo-tag (~> 2.0)
179 |     jekyll-theme-primer (0.6.0)
180 |       jekyll (> 3.5, < 5.0)
181 |       jekyll-github-metadata (~> 2.9)
182 |       jekyll-seo-tag (~> 2.0)
183 |     jekyll-theme-slate (0.2.0)
184 |       jekyll (> 3.5, < 5.0)
185 |       jekyll-seo-tag (~> 2.0)
186 |     jekyll-theme-tactile (0.2.0)
187 |       jekyll (> 3.5, < 5.0)
188 |       jekyll-seo-tag (~> 2.0)
189 |     jekyll-theme-time-machine (0.2.0)
190 |       jekyll (> 3.5, < 5.0)
191 |       jekyll-seo-tag (~> 2.0)
192 |     jekyll-titles-from-headings (0.5.3)
193 |       jekyll (>= 3.3, < 5.0)
194 |     jekyll-watch (2.2.1)
195 |       listen (~> 3.0)
196 |     jemoji (0.12.0)
197 |       gemoji (~> 3.0)
198 |       html-pipeline (~> 2.2)
199 |       jekyll (>= 3.0, < 5.0)
200 |     kramdown (2.3.2)
201 |       rexml
202 |     kramdown-parser-gfm (1.1.0)
203 |       kramdown (~> 2.0)
204 |     liquid (4.0.3)
205 |     listen (3.7.1)
206 |       rb-fsevent (~> 0.10, >= 0.10.3)
207 |       rb-inotify (~> 0.9, >= 0.9.10)
208 |     mercenary (0.3.6)
209 |     minima (2.5.1)
210 |       jekyll (>= 3.5, < 5.0)
211 |       jekyll-feed (~> 0.9)
212 |       jekyll-seo-tag (~> 2.1)
213 |     minitest (5.16.3)
214 |     nokogiri (1.13.9-arm64-darwin)
215 |       racc (~> 1.4)
216 |     octokit (4.25.1)
217 |       faraday (>= 1, < 3)
218 |       sawyer (~> 0.9)
219 |     pathutil (0.16.2)
220 |       forwardable-extended (~> 2.6)
221 |     public_suffix (4.0.7)
222 |     racc (1.6.0)
223 |     rb-fsevent (0.11.2)
224 |     rb-inotify (0.10.1)
225 |       ffi (~> 1.0)
226 |     rexml (3.2.5)
227 |     rouge (3.26.0)
228 |     ruby2_keywords (0.0.5)
229 |     rubyzip (2.3.2)
230 |     safe_yaml (1.0.5)
231 |     sass (3.7.4)
232 |       sass-listen (~> 4.0.0)
233 |     sass-listen (4.0.0)
234 |       rb-fsevent (~> 0.9, >= 0.9.4)
235 |       rb-inotify (~> 0.9, >= 0.9.7)
236 |     sawyer (0.9.2)
237 |       addressable (>= 2.3.5)
238 |       faraday (>= 0.17.3, < 3)
239 |     simpleidn (0.2.1)
240 |       unf (~> 0.1.4)
241 |     terminal-table (1.8.0)
242 |       unicode-display_width (~> 1.1, >= 1.1.1)
243 |     thread_safe (0.3.6)
244 |     typhoeus (1.4.0)
245 |       ethon (>= 0.9.0)
246 |     tzinfo (1.2.10)
247 |       thread_safe (~> 0.1)
248 |     unf (0.1.4)
249 |       unf_ext
250 |     unf_ext (0.0.8.2)
251 |     unicode-display_width (1.8.0)
252 |     webrick (1.7.0)
253 |     zeitwerk (2.6.6)
254 | 
255 | PLATFORMS
256 |   arm64-darwin-21
257 | 
258 | DEPENDENCIES
259 |   github-pages (~> 227)
260 |   http_parser.rb (~> 0.6.0)
261 |   minima (= 2.5.1)
262 |   tzinfo (>= 1, < 3)
263 |   tzinfo-data
264 |   wdm (~> 0.1.1)
265 |   webrick (>= 1.7.0)
266 | 
267 | BUNDLED WITH
268 |    2.3.7
269 | 


--------------------------------------------------------------------------------
/docs/_config.yml:
--------------------------------------------------------------------------------
 1 | # Welcome to Jekyll!
 2 | #
 3 | # This config file is meant for settings that affect your whole blog, values
 4 | # which you are expected to set up once and rarely edit after that. If you find
 5 | # yourself editing this file very often, consider using Jekyll's data files
 6 | # feature for the data you need to update frequently.
 7 | #
 8 | # For technical reasons, this file is *NOT* reloaded automatically when you use
 9 | # 'bundle exec jekyll serve'. If you change this file, please restart the server process.
10 | #
11 | # If you need help with YAML syntax, here are some quick references for you:
12 | # https://learn-the-web.algonquindesign.ca/topics/markdown-yaml-cheat-sheet/#yaml
13 | # https://learnxinyminutes.com/docs/yaml/
14 | #
15 | # Site settings
16 | # These are used to personalize your new site. If you look in the HTML files,
17 | # you will see them accessed via {{ site.title }}, {{ site.email }}, and so on.
18 | # You can create any custom variable you would like, and they will be accessible
19 | # in the templates via {{ site.myvariable }}.
20 | 
21 | title: Statement
22 | author: Julien Dutant, Thomas Hodgson
23 | description: >- #this means to ignore newlines until "baseurl:"
24 |   Statement is a versatile Pandoc lua filter to write theorems and
25 |   other statements in Markdown and convert them to multiple output
26 |   formats.
27 | markdown: kramdown # for automatic toc
28 | domain: dialoa.github.io
29 | url: https://dialoa.github.io/statement/
30 | baseurl: /statement/
31 | github_username: jdutant
32 | github_repository: statement
33 | 
34 | # Build settings
35 | theme: minima
36 | #plugins:
37 | #  - jekyll-feed
38 | 
39 | # Exclude from processing.
40 | # The following items will not be processed, by default.
41 | # Any item listed under the `exclude:` key here will be automatically added to
42 | # the internal "default list".
43 | #
44 | # Excluded items can be processed by explicitly listing the directories or
45 | # their entries' file path in the `include:` list.
46 | #
47 | #   - .jekyll-cache/
48 | #   - gemfiles/
49 | #   - Gemfile
50 | #   - Gemfile.lock
51 | #   - node_modules/
52 | #   - vendor/bundle/
53 | #   - vendor/cache/
54 | #   - vendor/gems/
55 | #   - vendor/ruby/


--------------------------------------------------------------------------------
/docs/_data/menu.yml:
--------------------------------------------------------------------------------
 1 | pages:
 2 | 
 3 | - title: Home
 4 |   url: index.html
 5 | 
 6 | - title: Quick tour
 7 |   url: /quick-tour/
 8 | 
 9 | - title: Manual
10 |   url: /manual/
11 | 


--------------------------------------------------------------------------------
/docs/_includes/header.html:
--------------------------------------------------------------------------------
 1 | <header class="site-header" role="banner">
 2 | 
 3 |   <div class="wrapper">
 4 |     {%- assign default_paths = site.pages | map: "path" -%}
 5 |     {%- assign page_paths = site.header_pages | default: default_paths -%}
 6 |     <a class="site-title" rel="author" href="{{ "/" | relative_url }}">{{ site.title | escape }}</a>
 7 | 
 8 |     {%- if page_paths -%}
 9 |       <nav class="site-nav">
10 |         <input type="checkbox" id="nav-trigger" class="nav-trigger" />
11 |         <label for="nav-trigger">
12 |           <span class="menu-icon">
13 |             <svg viewBox="0 0 18 15" width="18px" height="15px">
14 |               <path d="M18,1.484c0,0.82-0.665,1.484-1.484,1.484H1.484C0.665,2.969,0,2.304,0,1.484l0,0C0,0.665,0.665,0,1.484,0 h15.032C17.335,0,18,0.665,18,1.484L18,1.484z M18,7.516C18,8.335,17.335,9,16.516,9H1.484C0.665,9,0,8.335,0,7.516l0,0 c0-0.82,0.665-1.484,1.484-1.484h15.032C17.335,6.031,18,6.696,18,7.516L18,7.516z M18,13.516C18,14.335,17.335,15,16.516,15H1.484 C0.665,15,0,14.335,0,13.516l0,0c0-0.82,0.665-1.483,1.484-1.483h15.032C17.335,12.031,18,12.695,18,13.516L18,13.516z"/>
15 |             </svg>
16 |           </span>
17 |         </label>
18 | 
19 |         <div class="trigger">
20 |           {%- for item in site.data.menu.pages -%}
21 |             <a class="page-link" href="{{ item.url | relative_url }}">{{ item.title | escape }}</a>
22 |           {%- endfor -%}
23 |           {%- include repo.html -%}
24 |         </div>
25 |       </nav>
26 |     {%- endif -%}
27 |   </div>
28 | </header>
29 | 


--------------------------------------------------------------------------------
/docs/_includes/repo.html:
--------------------------------------------------------------------------------
1 | {%- if site.github_username -%}<a class="page-link" href="https://github.com/{{ site.github_username }}/{{ site.github_repository }}" title="See Github repository: {{ site.github_username }}/{{ site.github_repository }}"><svg class="svg-icon"><use xlink:href="{{ '/assets/minima-social-icons.svg#github' | relative_url }}"></use></svg></a>{%- endif -%}
2 | 


--------------------------------------------------------------------------------
/docs/img/thm-spivak-html-docx.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dialoa/statement/57d3f2b94520ec5013735af33d14e4d536686664/docs/img/thm-spivak-html-docx.png


--------------------------------------------------------------------------------
/docs/img/thm-spivak.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dialoa/statement/57d3f2b94520ec5013735af33d14e4d536686664/docs/img/thm-spivak.png


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | layout: home
  3 | nav_order: 1 # for just-the-docs
  4 | ---
  5 | 
  6 | __Statement__ is a Pandoc lua filter to handle theorems and other kinds
  7 | of statements in markdown.
  8 | 
  9 | Write theorems and other labelled, numbered or plain statements in
 10 | markdown. Convert them to multiple output formats using [Pandoc].
 11 | 
 12 | Get started with a [quick tour][tour] or read the [manual].
 13 | 
 14 | * toc
 15 | {:toc}
 16 | 
 17 | ## Illustration
 18 | 
 19 | Save the following as `source.md`:
 20 | 
 21 | ```
 22 | Theorem. (from Spivak 1967) {#fthc}
 23 | : Let $f$ be integrable on $[a,b]$, and define $F$ on $[a,b]$ by
 24 | 
 25 |     $$F(x) = \int_a^x f.$$
 26 | 
 27 |     If $f$ is continuous at $c$ in $[a,b]$ then $F$ is differentiable
 28 |     at $c$, and
 29 | 
 30 |     $$F'(c) = f(c).$$
 31 | 
 32 |     (If $c = a$ or $b$, then $F'(c)$ is understood to mean the right-
 33 |     or left-hand derivative of $F$.)
 34 | 
 35 | @Pre:fthc is known as the fundamental theorem of calculus.
 36 | ```
 37 | 
 38 | and run `pandoc -L statement.lua source.md -o output.pdf` to get the
 39 | PDF:
 40 | 
 41 | ![Example output](img/thm-spivak.png 'Example of statement PDF output')
 42 | 
 43 | Change `output.pdf` for other output formats:
 44 | 
 45 | ![Example html and MS Word output](img/thm-spivak-html-docx.png
 46 | 'Example of statement PDF output')
 47 | 
 48 | ## Features
 49 | 
 50 | Multiplaform, free and open source. No dependency other than Pandoc 
 51 | and a LaTeX distribution for PDF output.
 52 | 
 53 | * 20+ predefined statement kinds in AMS style (theorem, proof,
 54 |   definition, corollary, lemma, ...). 
 55 | * Define new statement kinds and/or redefine the defaults.
 56 | * Unnumbered and custom label statements are specified on the fly, no
 57 |   need to define them.
 58 | * Optionally count theorems within section, chapter etc. 
 59 | * Localization in 30+ languages: Théorème, Věta, Θεώρημα, Теорема. No
 60 |   need to mix English code in your text.
 61 | * Indented statement style suitable for principles, vignettes, alerts,
 62 |   tips and other block content that is not a quote. 
 63 | * Cross-reference statements with two syntaxes: citation (simple) or
 64 |   link (detailed control). Can be mixed within a single document. 
 65 | * Automatic cross-references prefixes ('Theorem 1'). Optional; 
 66 |   with and without can be mixed in a single document. 
 67 | * Consecutive cross-references are collated ('1.1-1.3').
 68 | * Two markdown syntaxes for statement: definition list (lean) or fenced div
 69 |   (explicit). Can be mixed within a single document.
 70 | * Customize statement styles: fonts, spacing, punctuation, numbers
 71 |   before label, linebreak after label. 
 72 |   * Full support in LaTeX/PDF output (using `amsthm` and `hyperref`) 
 73 |     and html output (using CSS). 
 74 |   * Partial support in all other output formats (using native Pandoc
 75 |     elements: definition lists, empahsis, ...).
 76 | * Semantically correct JATS XML output using the `<statement>` tag.
 77 | * Handles some LaTeX quirks, e.g. lists in a theorem. 
 78 | * Process documents created for previous theorem filters:
 79 |   [pandoc-amsthm] and [pandoc-theorems]. (partial support)
 80 | * Compatible with equation numbering filters: [pandoc-crossref],
 81 |   [pandoc-eqnos]
 82 | * Disable definition list and citation syntax if needed.
 83 | * Disable `amsthm` package commands in LaTeX if needed.
 84 | 
 85 | 
 86 | ## Limitations
 87 | 
 88 | * LaTeX outputs: uses hyperlinks rather than LaTeX's native `\label`
 89 |   and `\ref` commands. Support for using them planned. Support for
 90 |   `cleveref` could be considered too.
 91 | * Docx output: relies on generic Pandoc markdown styling. Support for
 92 |   `docx` styles should be added.
 93 | * JATS XML output: cannot include citations in a statement's info. 
 94 |   (Due to a limitation of Pandoc; workaround planned.)
 95 | * Styling: no full control of the statement heading format (unlike
 96 |   AMSthm package's head specification in LaTeX).
 97 | * Cross-references prefixes: only singular ("Theorem"). Support for 
 98 |   providing plurals and shortened ones ("Thm.") planned.
 99 | * Localisation: only singulars, plural forms should be added. 
100 | * [pandoc-amsthm] compatibility: does not read the label / info
101 |   attributes of fenced divs.
102 | * Read from LaTeX. Pandoc reads theorems in a LaTeX document but 
103 |   directly convets them to text. In the future the filter should include
104 |   a reader that recognizes Pandoc-generated statements and parses them
105 |   as statements. 
106 | 
107 | ## Credits
108 | 
109 | Developed by the Dialectica Open Access team as part of Markdown-based 
110 | workflow for the production of high-quality academic journals.
111 | 
112 | Open source, [MIT License][MIT]. See [project
113 | repository][project_repo] for details.
114 | 
115 | Copyright 2022 [Julien Dutant][jdutant], [Thomas Hodgson][twsh].
116 | 
117 | ## Acknowledgments
118 | 
119 | This filter is inspired by:
120 | 
121 | * The [JATS specification][JATS]'s `<statement>` tag for the idea.
122 | * Slim "Sarah" Slim's [pandoc-theorems] for its definition list
123 |   syntax.
124 | * Kolen Chung's [pandoc-amsthm] by its statement syntax and
125 |   metadata definitions.
126 | * Nikolay Yakimov's [pandoc-crossref] for its citation syntax.
127 | * John MacFarlane, Albert Krewinkel and other Pandoc Lua filter
128 |   contributors (in [Pandoc's Lua filter manual][PandocLua] and
129 |   the [lua filters repository][LuaFilters])
130 | 
131 | Thanks to:
132 | 
133 | * [Pandoc] and its [Lua filters extension][PandocLua] (John MacFarlane,
134 |   Albert Krewinkel and contributors).
135 | * [LyX contributors][LyX] for common theorems and their translations.
136 | 
137 | [jdutant]: https://github.com/jdutant/
138 | [twsh]: https://github.com/twsh
139 | [project_repo]: https://github.com/jdutant/statement
140 | [tour]: quick-tour
141 | [manual]: manual
142 | [Pandoc]: https://pandoc.org
143 | [PandocLua]: https://pandoc.org/lua-filters.html
144 | [LuaFilters]: https://github.com/pandoc/lua-filters
145 | [MIT]: https://opensource.org/licenses/MIT
146 | [LyX]: https://www.lyx.org
147 | [JATS]: https://jats.nlm.nih.gov/publishing/
148 | [AMSthm]: https://ctan.org/pkg/amsthm
149 | [pandoc-amsthm]: https://github.com/ickc/pandoc-amsthm
150 | [pandoc-theorems]: https://github.com/sliminality/pandoc-theorem
151 | [pandoc-crossref]: https://github.com/lierdakil/pandoc-crossref
152 | [pandoc-eqnos]: https://github.com/tomduck/pandoc-eqnos
153 | 


--------------------------------------------------------------------------------
/docs/manual.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | layout: page
  3 | title: Manual
  4 | permalink: /manual/
  5 | nav_order: 3 # for just-the-docs
  6 | ---
  7 | 
  8 | **DOCUMENTATION IN PROGRESS**
  9 | 
 10 | {% raw %}
 11 | 
 12 | ## Pre-defined statement kinds
 13 | 
 14 | `algorithm`, `assumption`, `axiom`, `claim`, `conclusion`,
 15 | `condition`, `conjecture`, `corollary`, `criterion`, `definition`,
 16 | `example`, `exercise`, `fact`, `lemma`, `note`, `problem`, `proof`,
 17 | `proposition`, `question`, `remark`, `solution`, `summary`, `theorem`.
 18 | 
 19 | ## Supported locales
 20 | 
 21 | `ar`, `bg`, `ca`, `cs`, `da`, `de`, `el`, `en`, `es`, `eu`, `fi`,
 22 | `fr`, `gl`, `he`, `hr`, `hu`, `ia`, `id`, `it`, `ja`, `ko`, `nb`,
 23 | `nl`, `nn`, `pl`, `pt_br`, `pt_pt`, `ro`, `ru`, `sk`, `sl`, `sr`,
 24 | `sv`, `tr`, `uk`, `zh_cn`, `zh_tw`. 
 25 | 
 26 | ## Troubleshooting
 27 | 
 28 | ### attempt to compare nil with number
 29 | 
 30 | ```
 31 | warning  (node filter): error: ...e/2022/texmf-dist/tex/generic/babel/babel-bid
 32 | i-basic.lua:155: attempt to compare nil with number
 33 | ```
 34 | 
 35 | This bug can be produced by a statement with a custom label containing
 36 | an __uppercase letter followed by a dash__, such as:
 37 | 
 38 | ```
 39 | ::: statement
 40 | __L-a__. This statement might generate an error!
 41 | :::
 42 | ```
 43 | 
 44 | __Fix 1__. Put the dash in a `\textrm{...}` command:
 45 | 
 46 |  ```
 47 | ::: statement
 48 | __L\textrm{-}a__. This will not generate an error.
 49 | :::
 50 | ```
 51 | 
 52 | This still comes out as a simple dash in formats other than LaTeX.
 53 | 
 54 | __Fix 2__. Surround the dash with spaces
 55 | 
 56 | ```
 57 | ::: statement
 58 | __L - a__. This will not generate an error.
 59 | :::
 60 | ```
 61 | 
 62 | A longer dash probably looks better:
 63 | 
 64 | ```
 65 | ::: statement
 66 | __L -- a__. This will not generate an error.
 67 | :::
 68 | ```
 69 | 
 70 | If that's not satisfying, and you don't want to change the 
 71 | statement label, you will have to change your font or 
 72 | your pdf engine.
 73 | 
 74 | __Details__. This is not a statement filter bug, but a bug within
 75 | LaTeX (as of nov 2022). It arises when using the `lualatex` pdf
 76 | engine and certain fonts (e.g. Libertinus and STIX Two Text 
 77 | generate it, Times New Roman, Helvetica Neue, Avenir don't). 
 78 | 
 79 | The bug is a conflict between the `amsthm` and `babel` (specifically, I
 80 | suspect, its `luababel` component) packages. It can be generated in LaTeX
 81 | itself, e.g:
 82 | 
 83 | 
 84 |  ~~~ {.latex}
 85 | 
 86 |  \documentclass{article}
 87 | \usepackage{amsthm}
 88 | \usepackage{fontspec}
 89 | \setmainfont{Libertinus Serif}
 90 | % The error appears with bidi=basic, not bidi=default
 91 | \usepackage[bidi=basic]{babel}
 92 | 
 93 | \begin{document}
 94 | 
 95 | \newtheorem*{statement}{A-b} % generates an error
 96 | % \newtheorem*{statement}{{A}-b} % generates an error
 97 | % \newtheorem*{statement}{A{-}b} % generates an error too
 98 | \newtheorem*{statement}{a-b} % does not generate an error (only upper case letters)
 99 | 
100 | \end{document}
101 | 
102 | ~~~
103 | 
104 | ### `calc` needed
105 | 
106 | The `calc` package is needed to handle statements placed
107 | within list (`itemize`/`enumerate` environements). The default Pandoc
108 | template for LaTeX loads it, but if you use a custom template instead
109 | its preamble should contain `\usepackage{calc}`.
110 | 
111 | 
112 | [Pandoc]: https://pandoc.org
113 | [PM]: https://pandoc.org/MANUAL.html
114 | [releases]: https://github.com/jdutant/statement/releases/tag/latest
115 | [PM-userdata]: https://pandoc.org/MANUAL.html#option--data-dir
116 | [PM-luafilter]: https://pandoc.org/MANUAL.html#option--lua-filter
117 | 
118 | 
119 | [manual]: manual
120 | [PandocLua]: https://pandoc.org/lua-filters.html
121 | 
122 | {% endraw %}


--------------------------------------------------------------------------------
/extras/parser.lua:
--------------------------------------------------------------------------------
  1 | -- Create a Setup.LOCALE definition from the Lyx file layouttranslations
  2 | -- Usage lua parser.lua > Setup.LOCALE.lua
  3 | -- source file must be named layouttranslations, part of LyX
  4 | --
  5 | -- Credit: LyX <www.lyx.org> contributors for the translations
  6 | 
  7 | -- MODEL; only the entries presented here will be copied
  8 | -- this also allows us to override LyX's translations
  9 | MODEL = {
 10 | 		en = {
 11 | 			theorem = 'Theorem',
 12 | 			corollary = 'Corollary',
 13 | 			lemma = 'Lemma',
 14 | 			proposition = 'Proposition',
 15 | 			conjecture = 'Conjecture',
 16 | 			fact = 'Fact',
 17 | 			definition = 'Definition',
 18 | 			example = 'Example',
 19 | 			problem = 'Problem',
 20 | 			exercise = 'Exercise',
 21 | 			solution = 'Solution',
 22 | 			remark = 'Remark',
 23 | 			claim = 'Claim',
 24 | 			proof = 'Proof',
 25 | 			axiom = 'Axiom',
 26 | 			criterion = 'Criterion',
 27 | 			algorithm = 'Algorithm',
 28 | 			condition = 'Condition',
 29 | 			note = 'Note',
 30 | 			notation = 'Notation',
 31 | 			summary = 'Summary',
 32 | 			conclusion = 'Conclusion',
 33 | 			assumption = 'Assumption',
 34 | 			hypothesis = 'Hypothesis',
 35 | 			question = 'Question',
 36 | 		},
 37 | 		de = {
 38 | 			hypothesis = 'Annahme',
 39 | 		},
 40 | 		es = {
 41 | 			hypothesis = 'Hipótesis',
 42 | 		},
 43 | 		fr = {
 44 | 			proof = 'Démonstration',
 45 | 			assumption = 'Supposition',
 46 | 			hypothesis = 'Hypothèse',
 47 | 		},
 48 | 		it = {
 49 | 			hypothesis = 'Ipotesi',
 50 | 		}
 51 | }
 52 | 
 53 | -- return the LyX file as string
 54 | function read_file(name)
 55 | 	local name = name or 'layouttranslations'
 56 | 	f = io.open(name, 'r')
 57 | 	if f then
 58 | 		local contents = f:read('a')	
 59 | 		f:close()
 60 | 		return contents
 61 | 	end
 62 | end
 63 | 
 64 | -- split the file by languages
 65 | function split_languages(str)
 66 | 	local pattern = 'Translation%s(.-)\nEnd'
 67 | 	local result = {}
 68 | 	--local matches = string.gmatch(str, pattern)
 69 | 	for match in str:gmatch(pattern) do
 70 | 		result[#result + 1] = match
 71 | 	end
 72 | 	return result
 73 | end
 74 | 
 75 | -- parse a language into tag and dictionary
 76 | function parse_language(str)
 77 | 	local tag = str:match('^%g+') -- first string of printable chars is lang label
 78 | 	local dic = {}
 79 | 	-- get rid of 'de_alt' language
 80 | 	if tag == 'de_alt' then 
 81 | 		return nil
 82 | 	end
 83 | 	-- tag is case-insensitive, must be lowercase
 84 | 	tag = tag:lower()
 85 | 
 86 | 	-- create the dictionary
 87 | 	for line in str:gmatch('(.-)\n') do
 88 | 		key,translation = line:match('"([%w%s]+)"%s"(.+)"')
 89 | 		-- if key found, find its lua key in MODEL
 90 | 		if key then
 91 | 			for lua_key,eng in pairs(MODEL.en) do
 92 | 				if eng == key then
 93 | 					dic[lua_key] = translation
 94 | 				end
 95 | 			end
 96 | 		end
 97 | 	end
 98 | 	return {
 99 | 		tag = tag,
100 | 		dictionary = dic
101 | 	}
102 | end
103 | 
104 | function find_in_list(list, needle)
105 | 	local result
106 | 	for i = 1, #list do
107 | 		if list[i] == needle then
108 | 			result = i
109 | 			break
110 | 		end
111 | 	end
112 | 	return result
113 | end
114 | 
115 | -- locale: a langtag = dictionary map
116 | --					each dictionary is a entry = translation (string) map
117 | local locale = {} 
118 | -- languages is the list of language tags (for alphabetical sorting)
119 | local languages = {}
120 | -- entries is the list of dictionary entries in MODEL (for alphabetical sorting)
121 | local entries = {} -- list of keys in MODEL
122 | 
123 | -- read the file and split it into languages
124 | local matches = split_languages(read_file())
125 | 
126 | -- create the locale table
127 | for _,lang_str in pairs(matches) do
128 | 	local result = parse_language(lang_str, keys)
129 | 	if result then
130 | 		locale[result.tag] = result.dictionary
131 | 	end
132 | end
133 | 
134 | -- tune the locale table
135 | locale.pt = locale.pt_PT
136 | locale.zh = locale.zh_CN
137 | 
138 | -- build a list of dictionary entries keys present in MODEL
139 | for tag,dictionary in pairs(MODEL) do
140 | 	for k,_ in pairs(dictionary) do
141 | 		if not find_in_list(entries, k) then
142 | 			table.insert(entries, k)
143 | 		end
144 | 	end
145 | end
146 | 
147 | -- compare locale and MODEL, insert missing / changed keys
148 | for tag,dictionary in pairs(MODEL) do
149 | 	-- make a key by key comparison of the dictionaries
150 | 	if locale[tag] then
151 | 		for _,key in ipairs(entries) do
152 | 			if MODEL[tag][key] then
153 | 				if locale[tag][key] == MODEL[tag][key] then 
154 | 					-- io.stderr:write('Matching translation for '..key..'.\n')
155 | 				elseif locale[tag][key] then
156 | 					local lyx_version = locale[tag][key] or ''
157 | 					local my_version = MODEL[tag][key] or ''
158 | 					io.stderr:write('Lyx '..tag..' translation for '..key.. ', '
159 | 						..lyx_version ..' replaced by '..my_version..'.\n')
160 | 					locale[tag][key] = MODEL[tag][key]
161 | 				else -- no key in the LyX file, adding from MODEL
162 | 					io.stderr:write('No Lyx '..tag..' translation for '..key
163 | 						..', inserting '..MODEL[tag][key]..'.\n')
164 | 					locale[tag][key] = MODEL[tag][key]
165 | 				end
166 | 			end -- if MODEL[tag][key]
167 | 		end -- loop key in entries
168 | 	else 
169 | 		io.stderr:write('Language '..tag..' not found.\n')
170 | 	end
171 | end
172 | -- build a list of languages
173 | for tag,_ in pairs(locale) do
174 | 	if not find_in_list(languages, tag) then
175 | 		table.insert(languages, tag)
176 | 	end
177 | end
178 | -- sort the entries and languages lists alphabetically
179 | table.sort(entries)
180 | table.sort(languages)
181 | 
182 | -- built the lua code to define the table, in clean alphabetical order
183 | local result = 
184 | [[--- Setup.LOCALE: localize statement labels
185 | Setup.LOCALE = {
186 | ]]
187 | for _,tag in ipairs(languages) do
188 | 	result = result .. '\t\t' .. tag .. ' = {\n'
189 | 	for _,entry in ipairs(entries) do
190 | 		if locale[tag][entry] then
191 | 			result = result.. '\t\t\t' .. entry .. ' = "' .. locale[tag][entry] .. '",\n'
192 | 		end
193 | 	end
194 | 	result = result .. '\t\t' .. '},\n'
195 | end
196 | result = result .. '}\n'
197 | print(result)


--------------------------------------------------------------------------------
/src/Crossref.aggregate_references.lua:
--------------------------------------------------------------------------------
  1 | ---Crossref.aggregate_references: turn successive 
  2 | -- numbered references of the same kind into a list.
  3 | -- E.g. "Theorem 1;Theorem 1.2" -> "Theorem 1.1, 1.2"
  4 | -- "1.1; 1.2; 1.3" -> "1.2--1.3"
  5 | -- Whenever we find such a sequence we replace it by
  6 | -- the last item with:
  7 | --		- the first item's prefix
  8 | --		- some additional fields to specify the sequence
  9 | --@param references a list of reference items
 10 | function Crossref:aggregate_references(references)
 11 | 	local identifiers = self.identifiers -- points to the identifier table
 12 | 	local kinds = self.setup.kinds -- points to the kinds table
 13 | 	local new_references = pandoc.List:new()
 14 | 
 15 | 	---counters_are_shared: checks whether two items
 16 | 	-- are counted together.
 17 | 	local function counters_are_shared(item1,item2)
 18 | 		local kind1 = identifiers[item1.id].kind
 19 | 		local kind2 = identifiers[item2.id].kind
 20 | 		if kind1 == kind2
 21 | 				or kinds[kind1].counter == kind2
 22 | 				or kinds[kind2].counter == kind1 then
 23 | 			return true
 24 | 		else
 25 | 			return false
 26 | 		end
 27 | 	end
 28 | 
 29 | 	---labels_are_consecutive: checks that one item's number
 30 | 	-- precedes another. 
 31 | 	-- We require the last number to be consecutive, e.g.:
 32 | 	-- 2.9, 2.10 : ok
 33 | 	-- 2.9, 3.1 : not ok
 34 | 	--@param item1 the earlier reference list item
 35 | 	--@param item2 the later reference list item
 36 | 	local function labels_are_consecutive(item1,item2)
 37 | 		local label1 = stringify(identifiers[item1.id].label)
 38 | 		local label2 = stringify(identifiers[item2.id].label)
 39 | 		local count1 = tonumber(label1:match('%d+$'))
 40 | 		local count2 = tonumber(label2:match('%d+$'))
 41 | 		return count1 and count2 and count2 == count1 + 1 
 42 | 	end
 43 | 
 44 | 	---auto_prefixes_are_compatible: if citations have
 45 | 	-- auto prefixes, check that they are compatible.
 46 | 	-- if the two items have auto prefix flag, they 
 47 | 	-- need to be of the same kind.
 48 | 	--@param item1, item2, reference list items
 49 | 	local function auto_prefixes_are_compatible(item1, item2)
 50 | 		local mode1 = item1.agg_pre_mode or self:get_pre_mode(item)
 51 | 		local mode2 = item2.agg_pre_mode or self:get_pre_mode(item)
 52 | 		return mode1 == 'none' and mode2 == 'none'
 53 | 					 or identifiers[item1.id].kind == identifiers[item2.id].kind
 54 | 	end
 55 | 
 56 | 	-- Aggregate multiple references. Requirements:
 57 | 	-- same counter
 58 | 	-- not if the second has a prefix, unless it's the same
 59 | 	-- not if either has custom text to replace its label
 60 | 	-- consecutive numbers
 61 | 	-- compatible auto prefixes
 62 | 	-- 
 63 | 	-- Strategy. When we concatenate an item, we give it the previous
 64 | 	-- item's id (carried ofer since the first) and add two fields:
 65 | 	-- `agg_last_id`: id of current item of the sequence
 66 | 	-- `agg_first_id`: id of first item in the sequence
 67 | 	-- `agg_count`: how many merges have occurred
 68 | 	-- `agg_pre_mode`: string auto prefix flag or 'none'
 69 | 	-- When the loop is over, we use these to create new labels for the
 70 | 	-- aggregated items.
 71 | 	local prev_item
 72 | 	for i = 1, #references do
 73 | 		item = references[i]
 74 | 		-- do we aggregate this with the previous one?
 75 | 		if prev_item
 76 | 				and counters_are_shared(prev_item,item)
 77 | 				and (not prev_item.suffix or #prev_item.suffix == 0)
 78 | 				and not (item.text or prev_item.text)
 79 | 				and (not item.prefix 
 80 | 							or stringify(item.prefix) == stringify(prev_item.prefix))
 81 | 				and labels_are_consecutive(prev_item,item)
 82 | 				and auto_prefixes_are_compatible(prev_item, item) then
 83 | 
 84 | 			-- first item's id: use the previous item's id,
 85 | 			-- unless it's already carrying a first item's id
 86 | 			item.agg_first_id = prev_item.agg_first_id 
 87 | 													or prev_item.id
 88 | 			-- auto prefix activated: use the previous item's
 89 | 			-- auto prefix flag, unless it's already carrying that
 90 | 			-- flag from another status
 91 | 			item.agg_pre_mode = prev_item.agg_pre_mode 
 92 | 													or self:get_pre_mode(prev_item)
 93 | 
 94 | 			-- add one merge to the count
 95 | 			item.agg_count = prev_item.agg_count and prev_item.agg_count + 1
 96 | 												or 1
 97 | 
 98 | 			-- carry over from the first item:
 99 | 			-- prefix
100 | 			-- flags
101 | 			item.prefix = prev_item.prefix
102 | 			item.flags = prev_item.flags
103 | 
104 | 		-- not aggregating: if we had a previous item in waiting we store it 
105 | 		elseif prev_item then
106 | 				
107 | 			new_references:insert(prev_item)
108 | 		
109 | 		end
110 | 
111 | 		-- if that was the last item, we store it, otherwise we pass it to
112 | 		-- the next loop iteration.
113 | 		if i == #references then 
114 | 			new_references:insert(item)
115 | 		else
116 | 			prev_item = item
117 | 		end
118 | 
119 | 	end
120 | 
121 | 	return new_references
122 | end
123 | 
124 | 


--------------------------------------------------------------------------------
/src/Crossref.collect_identifiers.lua:
--------------------------------------------------------------------------------
 1 | ---Crossref:collect_identifiers: Collect identifiers of 
 2 | -- non-statements in the document.
 3 | -- Updates:
 4 | --		self.identifiers
 5 | --@param blocks pandoc Blocks, a list of Block elements
 6 | --@return nil
 7 | function Crossref:collect_identifiers()
 8 | 	local setup = self.setup
 9 | 	local blocks = self.doc.blocks
10 | 	local types_with_identifier = { 'CodeBlock', 'Div', 'Header', 
11 | 						'Table', 'Code', 'Image', 'Link', 'Span',	}
12 | 	local filter = {} -- filter to be applied to blocks
13 | 
14 | 	-- get_filter: generate a filter (elem -> elem) that registers
15 | 	-- non-duplicate IDs with type `type`.
16 | 	local function get_filter(type) 
17 | 		return function(elem)
18 | 			if elem.identifier and elem.identifier ~= '' then
19 | 				-- parse the identifier
20 | 				local id, attr = Crossref:parse_identifier(elem.identifier)
21 | 				-- register the type
22 | 				attr.type = type
23 | 				-- register or warn
24 | 				success = self:register_identifier(id, attr, 'strict')
25 | 				if not success then 
26 | 					message('WARNING', 'Duplicate identifier: '..id..'.')
27 | 				end
28 | 			end
29 | 
30 | 			end
31 | 	end
32 | 
33 | 	-- Div: register only if not a statement
34 | 	filter.Div = function (elem)
35 | 		if elem.identifier and elem.identifier ~= ''
36 | 				and not Statement:Div_is_statement(elem, setup) then
37 | 					get_filter('Div')(elem)
38 | 			end
39 | 	end
40 | 
41 | 	-- Generic function for remaining types
42 | 	for _,type in ipairs(types_with_identifier) do
43 | 		-- make sure we don't erase a filter already defined
44 | 		filter[type] = filter[type] or get_filter(type)
45 | 	end
46 | 
47 | 	-- run the filter through blocks
48 | 	blocks:walk(filter)
49 | 
50 | end
51 | 
52 | 
53 | 
54 | 


--------------------------------------------------------------------------------
/src/Crossref.get_pre_mode.lua:
--------------------------------------------------------------------------------
 1 | ---Crossref.get_pre_mode: what auto prefix an item uses
 2 | 	--@return string auto prefix flag or 'none'
 3 | function Crossref:get_pre_mode(item)
 4 | 	local flag_pattern = '^[pP]res?$'
 5 | 
 6 | 	for _,flag in ipairs(item.flags) do
 7 | 		if flag:match(flag_pattern) then
 8 | 			return flag
 9 | 		end
10 | 	end
11 | 	return 'none'
12 | end
13 | 


--------------------------------------------------------------------------------
/src/Crossref.lua:
--------------------------------------------------------------------------------
 1 | -- # Crossref class
 2 | 
 3 | --- Crossref: class for the Crossref object.
 4 | -- The class contains a table of identifiers, and 
 5 | -- a constructor for References objects.
 6 | Crossref = {}
 7 | 
 8 | -- Identifiers map
 9 | Crossref.identifiers = {
10 | 	-- id = { 
11 | 	--				type = string, 'Div', 'Header', ... or 'Statement',
12 | 	--				label = inlines, index (1.1, 1.3.2) or crossref label (custom, acronym)
13 | 	--				font = string, font specification for the crossref label
14 | 	--				kind = string, key of the setup.kinds table
15 | 	-- 			}
16 | }
17 | 
18 | --- References lists
19 | -- the parse functions return a list of reference items.
20 | -- items in these list have the following structure:
21 | -- reference = {
22 | --			id = string, key of the identifiers table,
23 | --			flags = list of strings, flags added to the target,
24 | --			prefix = inlines,
25 | --			suffix =	inlines,
26 | --			mode = nil or string, `Normal` or `InText`
27 | --			text = inlines, user-specified text instead of label (Link references)
28 | -- 			title = string, user-specified title (Link references)
29 | --			agg_first_id = nil or string, id of the first item in a sequence
30 | --			agg_count = nil or number, how many merges happened in aggregating
31 | --	}
32 | 
33 | 
34 | !input Crossref.collect_identifiers -- collect pre-existing identifiers
35 | 
36 | !input Crossref.parse_identifier -- parse any flags in an identifier 
37 | 
38 | !input Crossref.register_identifier -- register a new identifier
39 | 
40 | !input Crossref.process -- process a Link or Cite, converting crossreferences
41 | 
42 | !input Crossref.parse_target -- parse any flags in a reference target
43 | 
44 | !input Crossref.parse_Link -- tries to read a Link as crossreference
45 | 
46 | !input Crossref.parse_Cite -- tries to read Cite as crossreference
47 | 
48 | !input Crossref.write -- write a crossreferences list
49 | 
50 | !input Crossref.aggregate_references -- aggregate references, e.g. "1.1--1.3"
51 | 
52 | !input Crossref.get_pre_mode -- get the auto prefix mode of a reference
53 | 
54 | --- create a crossref object from a pandoc document and setup.
55 | -- @param doc pandoc Document
56 | -- @param setup Setup class object, the document's statements setup
57 | -- @return Crossref object
58 | function Crossref:new(doc, setup)
59 | 
60 | 	-- create an object of Crossref class
61 | 	local o = {}
62 | 	self.__index = self 
63 | 	setmetatable(o, self)
64 | 
65 | 	-- pointers 
66 | 	o.setup = setup -- points to the setup, needed by the class's methods
67 | 	o.doc = doc -- points to the document
68 | 
69 | 	-- collect ids of non-statement in the Pandoc document
70 | 	o:collect_identifiers()
71 | 
72 | 	return o
73 | 
74 | end
75 | 


--------------------------------------------------------------------------------
/src/Crossref.parse_Cite.lua:
--------------------------------------------------------------------------------
 1 | ---Crossref:parse_Cite: tries to parse a Cite element
 2 | -- as a list of crossreferences.
 3 | -- Mixes of crossreferences and biblio (or others) aren't allowed.
 4 | -- See `Crossref.lua` for a definition of reference items.
 5 | -- Uses:
 6 | -- 	self.identifiers
 7 | --@param: elem, pandoc Cite element
 8 | --@return: table, list of reference items, or nil
 9 | function Crossref:parse_Cite(cite)
10 | 	local identifiers = self.identifiers
11 | 
12 | 	-- Check whether citations include crossref and/or biblio refs
13 | 	local has_crossref, has_biblio_ref
14 | 
15 |   for _,citation in ipairs(cite.citations) do
16 |   	local id, flags = self:parse_target(citation.id)
17 |   	if identifiers[id] then 
18 |   		-- apply redirect if needed
19 |   		id = identifiers[id].redirect or id
20 |   		-- record if we found a crossreference citation or another type
21 |   		if identifiers[id].type == 'Statement' then
22 |           has_crossref = true
23 |       else
24 |           has_biblio_ref = true
25 |       end  		
26 |   	else
27 |   		has_biblio_ref = true
28 |   	end
29 |   end
30 | 
31 |   -- Return if it has biblio refs, with a warning if there was a mix.
32 |   if has_biblio_ref then
33 |   	if has_crossref then
34 | 	    message('WARNING', 'A citation mixes bibliographic references'
35 | 	        ..' with custom label references: '..stringify(cite.content))
36 | 	  end
37 |     return
38 | 	end
39 | 
40 | 	-- Otherwise build the references list
41 | 	references = pandoc.List:new()
42 | 
43 | 	for _,citation in ipairs(cite.citations) do
44 | 		local ref = {}
45 |   	ref.id, ref.flags = self:parse_target(citation.id)
46 |   	-- apply redirect if needed
47 |   	ref.id = identifiers[ref.id].redirect or ref.id
48 |   	-- mode: `Normal` or `InText`
49 |   	ref.mode = 	citation.mode == 'AuthorInText' and 'InText'
50 |   							or citation.mode == 'NormalCitation' and 'Normal'
51 |   							or nil
52 |   	-- prefix and suffix
53 |   	-- for uniformity with Links, space added
54 |   	if #citation.prefix > 0 then
55 |   		ref.prefix = citation.prefix:clone()
56 |   		ref.prefix:insert(pandoc.Space())
57 |   	end
58 |   	if #citation.suffix > 0 then
59 |   		ref.suffix = citation.suffix:clone()
60 |   		ref.suffix:insert(1, pandoc.Space())
61 |   	end
62 | 
63 |   	references:insert(ref)
64 | 
65 | 	end
66 | 
67 | 	return references
68 | 
69 | end
70 | 


--------------------------------------------------------------------------------
/src/Crossref.parse_Link.lua:
--------------------------------------------------------------------------------
 1 | ---Crossref:parse_Link: tries to parse a Link element  
 2 | -- as a crossreference. 
 3 | -- See `Crossref.lua` for a definition of reference items.
 4 | -- Uses:
 5 | --	self.identifiers
 6 | --@param: elem, pandoc Link element
 7 | --@return: table, list of (one) reference item or nil
 8 | function Crossref:parse_Link(link)
 9 | 	local identifiers = self.identifiers
10 | 	local id, flags
11 | 
12 | 	---parse_link_content: parses link content into
13 | 	-- prefix and suffix or custom text.
14 | 	-- The first <>, if any, says where the automatic text
15 | 	-- goes. Non-empty text without <> is a custom text.
16 | 	-- Examples:
17 | 	-- '' -> prefix = nil, suffix = nil, text = nil
18 | 	-- 'this statement' ->  text = 'this statement', prefix,suffix = nil,nil
19 | 	-- 'as in <>' -> prefix 'as in ', suffix,text = nil,nil
20 | 	-- 'as in (<>)' -> prefix 'as in (', suffix = ')', text = nil
21 | 	-- 'see (<>) above' -> prefix 'see (', suffix = ') above', text = nil
22 | 	-- Uses:
23 | 	--	self.identifires
24 | 	--@param: inlines, text of the link
25 | 	--@return: table, list of (one) reference item
26 | 	local function parse_link_content(inlines)
27 | 		local text, prefix, suffix
28 | 
29 | 		if #inlines > 0 then
30 | 			text = pandoc.List:new()
31 | 			-- by default, insert elements in the custom text
32 | 			-- but if we find <>, put what we have in prefix
33 | 			-- and the rest in suffix.
34 | 			for i = 1, #inlines do
35 | 				if inlines[i].t == 'Str'
36 | 						and inlines[i].text:match('<>') then
37 | 					-- put what we have so far in prefix, 
38 | 					-- the rest in suffix
39 | 					prefix = text
40 | 					text = nil
41 | 					suffix = pandoc.List:new()
42 | 					for j = i+1, #inlines do
43 | 						suffix:insert(inlines[j])
44 | 					end
45 | 					-- split the string if needed
46 | 					s,e = inlines[i].text:find('<>')
47 | 					if s > 1 then 
48 | 						prefix:insert(pandoc.Str(inlines[i].text:sub(1,s-1)))
49 | 					end
50 | 					if e < #inlines[i].text then
51 | 						suffix:insert(1, pandoc.Str(inlines[i].text:sub(e+1,-1)))
52 | 					end
53 | 					break
54 | 
55 | 				else
56 | 
57 | 					text:insert(inlines[i])
58 | 
59 | 				end
60 | 			end
61 | 		end
62 | 
63 | 		return text, prefix, suffix
64 | 	end
65 | 
66 | 	-- MAIN FUNCTION BODY
67 | 
68 | 	-- Check whether the link is crossref and set id
69 | 	local is_crossref = false
70 | 	if link.target:sub(1,1) == '#' then
71 | 		id, flags = self:parse_target(link.target:sub(2,-1))
72 | 		if identifiers[id] then
73 | 			-- redirect if needed
74 | 			id = identifiers[id].redirect or id
75 | 			-- check whether the target is a statement
76 | 			if identifiers[id].type == 'Statement' then
77 | 				is_crossref = true
78 | 			end
79 | 		end
80 | 	end
81 | 
82 | 	-- parse a crossreference if found
83 | 	if is_crossref then
84 | 		local ref = {}
85 | 		ref.id = id
86 | 		ref.flags = flags
87 | 		ref.mode = 'InText'
88 | 		ref.text, ref.prefix, ref.suffix =	parse_link_content(link.content)
89 | 		ref.title = link.title ~= '' and link.title or nil
90 | 
91 | 		return { ref }
92 | 	end
93 | end
94 | 


--------------------------------------------------------------------------------
/src/Crossref.parse_identifier.lua:
--------------------------------------------------------------------------------
 1 | ---Crossref:parse_identifier: Parse an element's
 2 | -- identifier and return a map for the identifiers table.
 3 | -- @TODO in the future we'll process any flags included
 4 | -- in the identifier like `g:` for global identifiers.
 5 | --@param str string the Pandoc element identifier
 6 | --@return id string the identifier proper
 7 | --@return attr map of identifier attributes or nil 
 8 | function Crossref:parse_identifier(str)
 9 | 	local id = str
10 | 	local attr = {}
11 | 
12 | 	--@TODO: extract any flags in str, set attributes
13 | 
14 | 	return id, attr
15 | end
16 | 
17 | 
18 | 
19 | 


--------------------------------------------------------------------------------
/src/Crossref.parse_target.lua:
--------------------------------------------------------------------------------
 1 | ---Crossref:parse_target: Parse a crossreference
 2 | -- target into flags (if any) and identifier.
 3 | --@param str string the crossreference target
 4 | --@return id string the identifier proper
 5 | --@return flags pandoc List of flags, might be empty
 6 | function Crossref:parse_target(str)
 7 | 	local flag_patterns = {'pre', 'Pre', 'pres', 'Pres', 'g'} -- Lua patterns
 8 | 	local separator = ':' -- could open to customization in the future
 9 | 	local flags = pandoc.List:new()
10 | 	local id
11 | 
12 | 	---extract_flag: extract one flag from the identifier
13 | 	--@param: str, string from which the flag is to be extracted
14 | 	--@param: flag, string, flag found
15 | 	--@param: remainder, string remainder of the string
16 | 	local function extract_flag(str)
17 | 		local i,j = str:find('^%w+'..separator)
18 | 		-- proceed only if non-empty remainder found
19 | 		if j and j < #str then
20 | 			local flag = str:sub(i,j - #separator)
21 | 			local remainder = str:sub(j+1, #str)
22 | 			-- return only if it's an official flag
23 | 			for _,pattern in ipairs(flag_patterns) do
24 | 				if flag:match(pattern) then
25 | 					return flag, remainder
26 | 				end
27 | 			end
28 | 		end
29 | 	end
30 | 
31 | 	-- Main function body
32 | 	while str do
33 | 		local flag, remainder = extract_flag(str)
34 | 		if flag then
35 | 			flags:insert(flag)
36 | 			str = remainder
37 | 		else
38 | 			id = str
39 | 			str = nil
40 | 		end
41 | 	end
42 | 
43 | 	return id, flags
44 | 
45 | end


--------------------------------------------------------------------------------
/src/Crossref.process.lua:
--------------------------------------------------------------------------------
 1 | ---Crossref:process: processes crossreferences in
 2 | -- a Pandoc Link or Cite, if present.
 3 | -- See `Crossref.lua` for the definition `references` lists.
 4 | function Crossref:process(elem)
 5 | 	if elem and elem.t then
 6 | 		
 7 | 		local references
 8 | 
 9 | 		if elem.t == 'Link' then
10 | 			references = self:parse_Link(elem)
11 | 		elseif elem.t == 'Cite' then
12 | 			references = self:parse_Cite(elem)
13 | 		end
14 | 
15 | 		if references then
16 | 			return self:write(references)
17 | 		end
18 | 		
19 | 	end
20 | end
21 | 


--------------------------------------------------------------------------------
/src/Crossref.register_identifier.lua:
--------------------------------------------------------------------------------
 1 | ---Crossref:register_identifier: register a new identifier.
 2 | -- Different modes are provided
 3 | -- 		- 'strict': register only if not already existing
 4 | --		- 'redirect': if already present, register under a new
 5 | --							id and redirect the original to the new
 6 | --		- 'new': register, using a new name if needed
 7 | -- The 'redirect' and 'new' modes are always successful.
 8 | --@param id string the desired identifier
 9 | --@param attr table map of attributes
10 | --@param mode (optional) string, mode (defaults to 'new')
11 | --@return id string the identifier registered or nil
12 | function Crossref:register_identifier(id, attr, mode)
13 | 	local identifiers = self.identifiers -- points to the identifiers table
14 | 	local id = id or '' -- in non-strict mode, empty id is ok
15 | 	local attr = attr or {}
16 | 	local mode = mode or 'new'
17 | 
18 | 	-- all identifiers must have a type
19 | 	if not attr.type then
20 | 		attr.type = 'Unknown'
21 | 	end
22 | 
23 | 	if mode == 'strict' and id ~= '' then
24 | 		if not identifiers[id] then
25 | 			identifiers[id] = attr
26 | 			return id
27 | 		end
28 | 	elseif mode == 'new' or mode == 'redirect' then
29 | 		-- ensure we have a new id
30 | 		local final_id = id
31 | 		local n = 0
32 | 		while final_id == '' or identifiers[final_id] do
33 | 			n = n + 1
34 | 			final_id = id..'-'..tostring(n)
35 | 		end
36 | 		-- register
37 | 		identifiers[final_id] = attr
38 | 		-- in redirect mode, redirect old id to new one
39 | 		if mode == 'redirect' then
40 | 			if identifiers[id] then
41 | 				identifiers[id].redirect = final_id
42 | 			end
43 | 		end
44 | 		-- return the final id
45 | 		return final_id
46 | 	end
47 | end
48 | 
49 | 
50 | 
51 | 


--------------------------------------------------------------------------------
/src/Crossref.write.lua:
--------------------------------------------------------------------------------
  1 | ---Crossref:write: write a crossreferences list for output
  2 | -- The basic output for an item is
  3 | -- 		[prefix][core][suffix]
  4 | -- whre [core] is:
  5 | --		[automatic_prefix ]number
  6 | -- Example: [see ][theorem ]1.2[ and following].
  7 | -- Uses:
  8 | --@param: elem, pandoc Link element
  9 | function Crossref:write(references)
 10 | 	local text = pandoc.text -- Pandoc's text module for utf8 strings
 11 | 	local identifiers = self.identifiers
 12 | 	local kinds = self.setup.kinds
 13 | 	local delimiters = self.setup.options.crossref_delimiters
 14 | 											or {'(',')'}
 15 | 	local mode = references[1].mode or 'Normal' -- mode from first ref
 16 | 	local inlines = pandoc.List:new()
 17 | 
 18 | 	--write_core: create a reference's core text
 19 | 	local function write_core(reference)
 20 | 		local mode = reference.agg_pre_mode 
 21 | 								or self:get_pre_mode(reference) -- auto prefix setting
 22 | 		-- if it has a custom text, we return that
 23 | 		if reference.text then
 24 | 			return reference.text
 25 | 		end
 26 | 		-- otherwise we build inlines
 27 | 		local inlines = pandoc.List:new()
 28 | 
 29 | 		-- write auto prefix 
 30 | 		-- capitalize: label is Inlines and its text might contain utf8
 31 | 		-- chars, we make the first char of the first Str element upper or
 32 | 		-- lower case.
 33 | 		if mode ~= 'none' then
 34 | 			local auto_pre = kinds[identifiers[reference.id].kind].label
 35 | 			if auto_pre and auto_pre[1] then
 36 | 				if auto_pre[1].t == 'Str' then
 37 | 					local str
 38 | 					if mode == 'pre' or mode == 'pres' then
 39 | 						str = text.lower(text.sub(auto_pre[1].text, 1, 1))
 40 | 					elseif mode == 'Pre' or mode == 'Pres' then
 41 | 						str = text.upper(text.sub(auto_pre[1].text, 1, 1))
 42 | 					end
 43 | 					str = str..text.sub(auto_pre[1].text, 2, -1)
 44 | 					auto_pre[1].text = str
 45 | 				end
 46 | 				inlines:extend(auto_pre)
 47 | 				inlines:insert(pandoc.Space())
 48 | 			end
 49 | 		end
 50 | 
 51 | 		-- write aggregate reference or simple reference
 52 | 		if reference.agg_first_id then
 53 | 			local id1 = reference.agg_first_id
 54 | 			local id2 = reference.id
 55 | 			local separator = reference.agg_count == 1
 56 | 											and { pandoc.Str(','), pandoc.Space() }
 57 | 											or { pandoc.Str(utf8.char(8211)) } -- en-dash
 58 | 			inlines:extend(identifiers[id1].label)
 59 | 			inlines:extend(separator)
 60 | 			inlines:extend(identifiers[id2].label)
 61 | 		else -- simple reference
 62 | 			local label = identifiers[reference.id].label
 63 | 			if label and #label > 0 then
 64 | 				inlines:extend(label)
 65 | 			else
 66 | 				inlines:insert(pandoc.Str('??'))
 67 | 			end
 68 | 		end
 69 | 
 70 | 		-- apply crossref_font if we have one
 71 | 		local crossref_font = identifiers[reference.id].crossref_font
 72 | 		if crossref_font then
 73 | 			inlines = Helpers.font_format_native(crossref_font)(inlines)
 74 | 		end
 75 | 
 76 | 		return inlines
 77 | 
 78 | 	end
 79 | 
 80 | 	-- MAIN FUNCTION BODY
 81 | 
 82 | 	-- aggregate sequences of consecutive references
 83 | 	if self.setup.options.aggregate_crossreferences then
 84 | 		references = self:aggregate_references(references)
 85 | 	end
 86 | 
 87 | 	for i = 1, #references do
 88 | 		reference = references[i]
 89 | 
 90 | 		-- create core
 91 | 		local core = write_core(reference)
 92 | 
 93 | 		-- values for the link element
 94 | 		local target = '#'..reference.id
 95 | 		local title = reference.title and reference.title ~= '' 
 96 | 									and reference.title:gsub('<>',stringify(core))
 97 | 									or stringify(core)
 98 | 
 99 | 		-- build inlines
100 | 		if reference.prefix then
101 | 			inlines:extend(reference.prefix)
102 | 		end
103 | 		inlines:insert( pandoc.Link(core, target, title) )
104 | 		if reference.suffix then
105 | 			inlines:extend(reference.suffix)
106 | 		end
107 | 
108 | 		-- add separator if needed
109 | 		if #references > 1 and i < #references then
110 |       inlines:extend({pandoc.Str(';'),pandoc.Space()})
111 |     end
112 | 
113 | 	end
114 | 
115 | 	-- adds brackets if needed
116 | 	if mode == 'Normal' then
117 | 	    inlines:insert(1, pandoc.Str(delimiters[1]))
118 | 	    inlines:insert(pandoc.Str(delimiters[2]))
119 | 	end
120 | 
121 |   return inlines
122 | 
123 | end
124 | 


--------------------------------------------------------------------------------
/src/Helpers.font_format.lua:
--------------------------------------------------------------------------------
 1 | --- Helpers.font_format: parse font features into the desired format
 2 | -- @param len Inlines or string to be interpreted
 3 | -- @param format (optional) desired format if other than FORMAT
 4 | -- @return string, font commands in the desired format or ''
 5 | Helpers.font_format = function (str, format)
 6 | 	local format = format or FORMAT
 7 | 	-- FEATURES and their conversion
 8 | 	local FEATURES = {
 9 | 		upright = {
10 | 			latex = '\\upshape',
11 | 			css = 'font-style: normal;',
12 | 		},
13 | 		italics = {
14 | 			latex = '\\itshape',
15 | 			css = 'font-style: italic;',
16 | 		},
17 | 		smallcaps = {
18 | 			latex = '\\scshape',
19 | 			css = 'font-variant: small-caps;',
20 | 		},
21 | 		bold = {
22 | 			latex = '\\bfseries',
23 | 			css = 'font-weight: bold;',
24 | 		},
25 | 		normal = {
26 | 			latex = '\\normalfont',
27 | 			css = 'font-style: normal; font-weight: normal; font-variant:normal;'
28 | 		}
29 | 	}
30 | 	-- provide some aliases
31 | 	local ALIASES = {
32 | 		italics = {'italic'},
33 | 		normal = {'normalfont'},
34 | 		smallcaps = {'small%-caps'}, -- used as a pattern, so `-` must be escaped
35 | 	}
36 | 
37 | 	-- within this function, format is 'css' when css features are needed
38 | 	if format:match('html') then
39 | 		format = 'css'
40 | 	end
41 | 
42 | 	-- ensure str is defined and a string
43 | 	str = type(str) == 'string' and str ~= '' and str
44 | 				or type(str) == 'Inlines' and #str > 0 and stringify(str)
45 | 				or nil
46 | 
47 | 	if str then
48 | 
49 | 		local result = ''
50 | 
51 | 		for feature,definition in pairs(FEATURES) do
52 | 			if str:match(feature) and definition[format] then
53 | 				result = result..definition[format]
54 | 			-- avoid multiple copies by only looking for aliases
55 | 			-- if main feature key not found and breaking if we find any alias 
56 | 			elseif ALIASES[feature] then 
57 | 				for _,alias in ipairs(ALIASES[feature]) do
58 | 					if str:match(alias) and definition[format] then
59 | 						result = result..definition[format]
60 | 						break -- ensures no multiple copies
61 | 					end
62 | 				end
63 | 			end
64 | 		end
65 | 
66 | 		return result
67 | 
68 | 	end
69 | 
70 | 	return ''
71 | 
72 | end


--------------------------------------------------------------------------------
/src/Helpers.font_format_native.lua:
--------------------------------------------------------------------------------
  1 | --- Helpers.font_format_native: parse font features into 
  2 | -- native pandoc elements: Emph, Strong, smallcaps Span.
  3 | -- Note that the function won't work if you pass it a List
  4 | -- that is not of type Blocks or Inlines. 
  5 | --@TODO requires >=2.17 to recognize Blocks and Inlines types
  6 | --@TODO provide Spans with classes for older Pandoc versions?
  7 | --@TODO type(elem) in Pandoc <2.17 doesn't return 'Inline' but 'Para' etc.
  8 | -- @param len Inlines or string to be interpreted
  9 | -- @return function, Inline(s) -> Inline(s) or Block(s) -> Block(s)
 10 | Helpers.font_format_native = function (str)
 11 | 	-- FEATURES and their conversion
 12 | 	local FEATURES = {
 13 | 		italics = 	function(inlines) 
 14 | 									return pandoc.Emph(inlines)
 15 | 								end,
 16 | 		smallcaps = function(inlines) 
 17 | 									return pandoc.SmallCaps(inlines)
 18 | 								end,
 19 | 		bold = 	function(inlines) 
 20 | 								return pandoc.Strong(inlines)
 21 | 							end,
 22 | 		underline = function(inlines) 
 23 | 									return pandoc.Underline(inlines)
 24 | 								end,
 25 | 		strikeout = function(inlines)
 26 | 									return pandoc.Strikeout(inlines)
 27 | 								end,
 28 | 		subscript = function(inlines)
 29 | 									return pandoc.Subscript(inlines)
 30 | 								end,
 31 | 		superscript = function(inlines) 
 32 | 									return pandoc.Superscript(inlines)
 33 | 								end,
 34 | 		code = function(inlines)
 35 | 									return pandoc.Code(stringify(inlines))
 36 | 								end,
 37 | 	}
 38 | 	-- provide some aliases
 39 | 	local ALIASES = {
 40 | 		italics = {'italic'},
 41 | 		normal = {'normalfont'},
 42 | 		smallcaps = {'small%-caps'}, -- used as a pattern, so `-` must be escaped
 43 | 	}
 44 | 
 45 | 	-- ensure str is defined and a string
 46 | 	str = type(str) == 'string' and str ~= '' and str
 47 | 				or type(str) == 'Inlines' and #str > 0 and stringify(str)
 48 | 				or nil
 49 | 
 50 | 	if str then
 51 | 
 52 | 		-- build a list of functions to be applied
 53 | 		local formatters = pandoc.List:new()
 54 | 
 55 | 		for feature,definition in pairs(FEATURES) do
 56 | 			if str:match(feature) then
 57 | 				formatters:insert( definition )
 58 | 			-- avoid multiple copies by only looking for aliases
 59 | 			-- if main feature key not found and breaking if we find any alias 
 60 | 			elseif ALIASES[feature] then 
 61 | 				for _,alias in ipairs(ALIASES[feature]) do
 62 | 					if str:match(alias) then
 63 | 						formatters:insert( definition )
 64 | 						break -- ensures no multiple copies
 65 | 					end
 66 | 				end
 67 | 			end
 68 | 		end
 69 | 
 70 | 		if #formatters > 0 then
 71 | 
 72 | 			-- Common Inlines formatting function
 73 | 			local inlines_format = 	function(inlines)
 74 | 													for _,formatter in ipairs(formatters) do
 75 | 														inlines = formatter(inlines)
 76 | 													end
 77 | 													return inlines
 78 | 												end
 79 | 
 80 | 			-- return a function that handles all types
 81 | 			-- 	- Inlines, Inline: wrap with inlines_format
 82 | 			-- 	- Blocks, Block: wrap the content of leaf blocks (those
 83 | 			--									whose content is inlines only)
 84 | 			return function (obj)
 85 | 				-- determine type
 86 | 				obj_type = (type(obj) == 'Inlines' or type(obj) == 'Inline'
 87 | 										or type(obj) == 'Blocks' or type(obj) == 'Block')
 88 | 										and type(obj)
 89 | 										or nil
 90 | 				if not obj_type and type(obj) == 'List' and obj[1] then
 91 | 					if type(obj[1]) == 'Inline' then
 92 | 						obj = pandoc.Inlines(obj)
 93 | 						obj_type = 'Inlines'
 94 | 					elseif type(obj[1] == 'Block') then
 95 | 						obj = pandoc.Blocks(obj)
 96 | 						obj_type = 'Blocks'
 97 | 					end
 98 | 				end
 99 | 				-- process object according to type and return it
100 | 					if obj_type == 'Inlines' or obj_type == 'Inline' then
101 | 						return inlines_format(obj)
102 | 					elseif obj_type == 'Block' and type(obj.content) == 'Inlines' then
103 | 						obj.content = inlines_format(obj.content)
104 | 						return obj
105 | 					elseif obj_type == 'Blocks' then
106 | 						return obj:walk( { 
107 | 								Block = function(elem)
108 | 										if elem.content and type(elem.content) == 'Inlines' then
109 | 											elem.content = inlines_format(elem.content)
110 | 											return elem
111 | 										end
112 | 									end 
113 | 							})
114 | 					else
115 | 						return obj
116 | 					end
117 | 				
118 | 				end
119 | 
120 | 		end
121 | 
122 | 	end
123 | 
124 | 	return function(obj) return obj end
125 | 
126 | end
127 | 


--------------------------------------------------------------------------------
/src/Setup.DEFAULTS.lua:
--------------------------------------------------------------------------------
 1 | --- Setup.DEFAULTS: default sets of kinds and styles
 2 | -- See amsthm documentation <https://www.ctan.org/pkg/amsthm>
 3 | -- the 'none' definitions are always included but they can be 
 4 | -- overridden by others default sets or the user.
 5 | Setup.DEFAULTS = {}
 6 | Setup.DEFAULTS.KINDS = {
 7 | 	none = {
 8 | 		statement = {prefix = 'sta', style = 'empty', counter='none'},
 9 | 	},
10 | 	basic = {
11 | 		theorem = { prefix = 'thm', style = 'plain', counter = 'self' },
12 | 		lemma = { prefix = 'lem', style = 'plain', counter = 'theorem' },
13 | 		corollary = { prefix = 'cor', style = 'plain', counter = 'theorem' },
14 | 		proposition = {prefix = 'prop', style = 'plain', counter = 'theorem' },
15 | 		conjecture = {prefix = 'conj', style = 'plain', counter = 'theorem' },
16 | 		fact = { style = 'plain', counter = 'theorem'},
17 | 		definition = {prefix = 'defn', style = 'definition', counter = 'theorem'},
18 | 		problem = {prefix = 'prob', style = 'definition', counter = 'theorem'},
19 | 		example = {prefix = 'exa', style = 'definition', counter = 'theorem'},
20 | 		exercise = {prefix = 'xca', style = 'definition', counter = 'theorem'},
21 | 		axiom = {prefix = 'ax', style = 'definition', counter = 'theorem'},
22 | 		solution = {prefix = 'sol', style = 'definition', counter = 'theorem'},
23 | 		remark = {prefix = 'rem', style = 'remark', counter = 'theorem'},
24 | 		claim = {prefix = 'claim', style = 'remark', counter = 'theorem'},
25 | 		proof = {prefix = 'proof', style = 'proof', counter = 'none'},
26 | 		criterion = {prefix = 'crit', style = 'plain', counter = 'theorem'},
27 | 		assumption = {prefix = 'ass', style = 'plain', counter = 'theorem'},
28 | 		algorithm = {prefix = 'alg', style = 'definition', counter = 'theorem'},
29 | 		condition = {prefix = 'cond', style = 'definition', counter = 'theorem'},
30 | 		question = {prefix = 'qu', style = 'definition', counter = 'theorem'},
31 | 		note = {prefix = 'note', style = 'remark', counter = 'theorem'},
32 | 		summary = {prefix = 'sum', style = 'remark', counter = 'theorem'},
33 | 		conclusion = {prefix = 'conc', style = 'remark', counter = 'theorem'},
34 | 	}
35 | }
36 | Setup.DEFAULTS.STYLES = {
37 | 	none = {
38 | 		empty = {
39 | 			margin_top = '1em',
40 | 			margin_bottom = '1em',
41 | 			margin_left = '2em',
42 | 			margin_right = '2em',
43 | 			body_font = '',
44 | 			indent = '0pt', -- applies to the label / first line only
45 | 			head_font = 'smallcaps',
46 | 			punctuation = '',
47 | 			space_after_head = '0pt', -- use '\n' or '\\n' or '\newline' for linebreak 
48 | 			heading_pattern = nil,
49 | 			custom_label_changes = {
50 | 											punctuation = '.',
51 | 											crossref_font = 'smallcaps',
52 | 											space_after_head = ' ',
53 | 			},
54 | 		},
55 | 	},
56 | 	basic = {
57 | 		plain = { do_not_define_in_latex = true,
58 | 			margin_top = '1em',
59 | 			margin_bottom = '1em',
60 | 			margin_left = nil,
61 | 			margin_right = nil,
62 | 			body_font = 'italics',
63 | 			indent = '0pt',
64 | 			head_font = 'bold',
65 | 			punctuation = '.',
66 | 			space_after_head = '1em',
67 | 			heading_pattern = nil,			
68 | 		 },
69 | 		definition = { do_not_define_in_latex = true,
70 | 			based_on = 'plain',
71 | 			body_font = '', -- '' used to reset the basis's field to nil
72 | 		 },
73 | 		remark = { do_not_define_in_latex = true,
74 | 			based_on = 'plain',
75 | 			body_font = '',
76 | 			head_font = 'italics',
77 | 		 },
78 | 		proof = { do_not_define_in_latex = false,
79 | 			based_on = 'plain',
80 | 			body_font = 'normal',
81 | 			head_font = 'italics',
82 | 		 }, -- Statement.write_style will take care of it
83 | 	},
84 | }


--------------------------------------------------------------------------------
/src/Setup.create_aliases.lua:
--------------------------------------------------------------------------------
 1 | ---Setup:create_aliases: create map of kind aliases
 2 | -- Populates self.aliases if the `aliases` options is set
 3 | function Setup:create_aliases()
 4 | 
 5 | 	if not self.options.aliases then
 6 | 		return
 7 | 	end
 8 | 	
 9 | 	-- add_alias: function to add an alias to self.aliases
10 | 	-- 		ensure it's a string, use lowercase for case-insensitive matches
11 | 	local function add_alias(alias, kind_key)
12 | 		alias = stringify(alias):lower()
13 | 		-- warn if clash
14 | 		if self.aliases[alias] and self.aliases[alias] ~= kind_key then
15 | 			message('WARNING', 'Cannot use `'..alias..'` as an alias of `'..kind_key..'`'
16 | 													..', it is already an alias of `'..self.aliases[alias]..'`.')
17 | 		else
18 | 			self.aliases[alias] = kind_key
19 | 		end
20 | 	end
21 | 
22 | 
23 | 	for kind_key,kind in pairs(self.kinds) do
24 | 		-- user-defined aliases?
25 | 		if kind.aliases then
26 | 			for _,alias in ipairs(kind.aliases) do
27 | 				add_alias(alias,kind_key)
28 | 			end
29 | 		end
30 | 		-- use the kind's prefix as alias, if any
31 | 		if kind.prefix then
32 | 			add_alias(kind.prefix,kind_key) 
33 | 		end
34 | 		-- us the kind's label
35 | 		if kind.label then
36 | 			add_alias(kind.label,kind_key)
37 | 		end
38 | 	end
39 | 
40 | 
41 | end
42 | 


--------------------------------------------------------------------------------
/src/Setup.create_counters.lua:
--------------------------------------------------------------------------------
 1 | --- Setup:create_counters create level counters based on statement kinds
 2 | -- Creates
 3 | --	self.counters
 4 | --@param format (optional) desired format if other than FORMAT
 5 | --@return nil, creates the self.counters table
 6 | function Setup:create_counters(format)
 7 | 	local format = format or FORMAT
 8 | 	local deepest_level = 0 -- deepest level needed
 9 | 	local reset_with_level = {} -- map kind = level
10 | 
11 | 	-- make the reset_with_level map
12 | 	-- and determine the deepest level needed
13 | 	for kind_key,definition in pairs(self.kinds) do
14 | 		local level = tonumber(definition.counter) or 
15 | 									self:get_level_by_LaTeX_name(definition.counter)
16 | 		if level then
17 | 			if level >=1 and level <= 6 then
18 | 				reset_with_level[kind_key] = level
19 | 				if level > deepest_level then
20 | 					deepest_level = level
21 | 				end
22 | 			else
23 | 				message('WARNING','Kind '..kind_key..' was assigned level '..tostring(level)
24 | 													..', which is outside the range 1-6 of Pandoc levels.'
25 | 													..' Counters for these statement may not work as desired.')
26 | 			end
27 | 		end
28 | 	end
29 | 
30 | 	-- create levels up to the level needed
31 | 	-- use Pandoc's number_offset if html output
32 | 	-- default format: '%s' for level 1, '%p.%s' for others
33 | 	for i=1, deepest_level do -- will not do anything if `deepest_level` is 0
34 | 		self.counters[i] = {
35 | 				count = FORMAT:match('html') and PANDOC_WRITER_OPTIONS.number_offset[i]
36 | 								or 0,
37 | 				reset = pandoc.List:new(),
38 | 				format = i == 1 and '%s'
39 | 											or '%p.%s',
40 | 		}
41 | 		for kind,level in pairs(reset_with_level) do
42 | 			if level == i then
43 | 				self.counters[i].reset:insert(kind)
44 | 			end
45 | 		end
46 | 	end
47 | 
48 | 	-- insert each kind in the reset list of its counter
49 | 
50 | 
51 | end
52 | 


--------------------------------------------------------------------------------
/src/Setup.create_kinds_and_styles.lua:
--------------------------------------------------------------------------------
 1 | ---Setup:create_kinds_and_styles: Create kinds and styles
 2 | -- Populates Setup.kinds and Setup.styles with
 3 | -- default and user-defined kinds and styles.
 4 | -- Localizes the language and create aliases.
 5 | -- Updates:
 6 | --		self.styles
 7 | --		self.kinds 
 8 | --		self.aliases
 9 | --@param meta pandoc Meta object, document's metadata
10 | --@return nil
11 | function Setup:create_kinds_and_styles(meta)
12 | 	local language = self.options.language
13 | 
14 | 	-- create default kinds and styles
15 | 	self:create_kinds_and_styles_defaults(meta)
16 | 
17 | 	-- create user-defined kinds and styles
18 | 	self:create_kinds_and_styles_user(meta)
19 | 
20 | 	-- @TODO read user-defined localizations?
21 | 
22 | 	-- Check that shared counters are well defined
23 | 	-- A kind can only share a counter with a kind that doesn't
24 | 	for kind, definition in pairs(self.kinds) do
25 | 		if definition.counter and self.kinds[definition.counter]
26 | 			and self.kinds[definition.counter].counter
27 | 			and self.kinds[self.kinds[definition.counter].counter] then
28 | 				message('ERROR', 'Statement kind `'..kind..'` shares a counter'
29 | 												..' with a statement kind that also shares a'
30 | 												..' counter (`'..definition.counter..'`).'
31 | 												..' This is not allowed, things may break.')
32 | 		end
33 | 	end
34 | 	
35 | 	-- Finalize the kinds table
36 | 	-- ensure all labels are Inlines
37 | 	-- localize statement labels that aren't yet defined
38 | 	for kind_key, kind in pairs(self.kinds) do
39 | 		if kind.label then
40 | 			kind.label = pandoc.Inlines(kind.label)
41 | 		else
42 | 			kind.label = self.LOCALE[language]
43 | 									and self.LOCALE[language][kind_key]
44 | 									and pandoc.Inlines(self.LOCALE[language][kind_key])
45 | 									or nil
46 | 		end
47 | 	end
48 | 
49 | 	-- populate the aliases map
50 | 	self:create_aliases()
51 | 
52 | end
53 | 


--------------------------------------------------------------------------------
/src/Setup.create_kinds_and_styles_defaults.lua:
--------------------------------------------------------------------------------
  1 | ---Setup.create_kinds_and_styles_defaults: create the default
  2 | -- kinds and styles.
  3 | --@param meta pandoc Meta object, document's metadata
  4 | --@return nil sets the Setup.kinds, Setup.styles, Setup.aliases tables
  5 | function Setup:create_kinds_and_styles_defaults(meta)
  6 | 	local chosen_defaults = 'basic' -- 'basic' unless user says otherwise
  7 | 
  8 | 	-- add_default_set: adds a given set of defaults to kinds and styles
  9 | 	local function add_default_set(set_key)
 10 | 		for kind,definition in pairs(self.DEFAULTS.KINDS[set_key]) do
 11 | 			self.kinds[kind] = definition
 12 | 		end
 13 | 		for style,definition in pairs(self.DEFAULTS.STYLES[set_key]) do
 14 | 			self.styles[style] = definition
 15 | 		end
 16 | 	end
 17 | 
 18 | 	-- based_on_styles: builds styles based on other styles
 19 | 	local function based_on_styles()
 20 | 
 21 | 		for style,definition in pairs(self.styles) do
 22 | 
 23 | 			if definition.based_on and self.styles[definition.based_on] then
 24 | 				source_style = self.styles[definition.based_on]
 25 | 				if source_style.based_on then
 26 | 					message('ERROR', 'Defaults misconfigured: style `'..style..'` '
 27 | 											..' is based on a style (`'..definition.based_on..'`)'
 28 | 											..' that is itself based on another style.'
 29 | 											..' this is not allowed.')
 30 | 				else
 31 | 
 32 | 					for key,value in pairs(source_style) do
 33 | 						if not definition[key] then
 34 | 							definition[key] = source_style[key]
 35 | 						end
 36 | 					end
 37 | 
 38 | 					-- '' keys in derived styles are used to erase fields
 39 | 					for key,value in pairs(definition) do
 40 | 						if value == '' then
 41 | 							definition[key] = nil
 42 | 						end
 43 | 					end
 44 | 
 45 | 					-- once defined, not based on anymore
 46 | 					-- (Ensures that if user redefines the basis style, it doesn't
 47 | 					--	affect new styles based on this derived style)
 48 | 					definition.based_on = nil
 49 | 
 50 | 					-- No need for this in Lua as tables are passed by references
 51 | 					-- but putting it there as a reminder of what happens
 52 | 					-- self.styles[style] = definition
 53 | 
 54 | 				end
 55 | 			end
 56 | 
 57 | 		end
 58 | 
 59 | 	end
 60 | 
 61 | 	-- MAIN FUNCTION BODY
 62 | 
 63 | 	-- does the user want to check the filter's DEFAULTS files?
 64 | 	if meta.statement and meta.statement['validate-defaults'] then
 65 | 		self:validate_defaults()
 66 | 	end
 67 | 
 68 | 	-- user-selected defaults?
 69 | 	if meta.statement and meta.statement.defaults then
 70 | 		local new_defaults = stringify(meta.statement.defaults)
 71 | 		if self.DEFAULTS.KINDS[new_defaults] then
 72 | 			chosen_defaults = new_defaults
 73 | 		end
 74 | 	end
 75 | 
 76 | 	-- add the 'none' defaults no matter what, then the chosen ones
 77 | 	add_default_set('none')
 78 | 	if chosen_defaults ~= 'none' then
 79 | 		add_default_set(chosen_defaults)
 80 | 	end
 81 | 
 82 | 	-- fill in styles based on other styles
 83 | 	based_on_styles()
 84 | 
 85 | 	-- styles: convert newlines in 'space_after_head' 
 86 | 	-- to linebreak_after_head = true
 87 | 	for style,definition in pairs(self.styles) do
 88 | 		if definition.space_after_head and
 89 | 			(definition.space_after_head == '\n'
 90 | 				or definition.space_after_head == '\\n'
 91 | 				or definition.space_after_head == '\\newline'
 92 | 				) then
 93 | 			self.styles[style].linebreak_after_head = true
 94 | 			self.styles[style].space_after_head = nil
 95 | 		end
 96 | 	end
 97 | 
 98 | 	-- if count_within, change defaults with 'self' counter 
 99 | 	-- to 'count_within' counter
100 | 	if self.options.count_within then
101 | 		for kind,definition in pairs(self.kinds) do
102 | 			if definition.counter == 'self' then 
103 | 				self.kinds[kind].counter = self.options.count_within
104 | 			end
105 | 		end
106 | 	end
107 | 
108 | end


--------------------------------------------------------------------------------
/src/Setup.font_format.lua:
--------------------------------------------------------------------------------
 1 | --- Setup:length_format: parse font features into the desired format
 2 | --@TODO what if a space is provided (space after head)
 3 | -- @param len Inlines or string to be interpreted
 4 | -- @param format (optional) desired format if other than FORMAT
 5 | -- @return string or function or nil
 6 | --				string specifying font features in the desired format 
 7 | --				or (native format) function Inlines -> Inlines
 8 | --				or nil
 9 | function Setup:font_format(str, format)
10 | 	local format = format or FORMAT
11 | 	local result = ''
12 | 	-- ensure str is defined and a string
13 | 	if not str then
14 | 		return nil
15 | 	end
16 | 	if type(str) ~= 'string' then
17 | 		if type(str) == 'Inlines' then
18 | 			str = stringify(str)
19 | 		else
20 | 			return nil
21 | 		end
22 | 	end
23 | 
24 | 	-- within this function, format is 'css' when css features are needed
25 | 	if format:match('html') then
26 | 		format = 'css'
27 | 	end
28 | 	-- FEATURES and their conversion
29 | 	local FEATURES = {
30 | 		upright = {
31 | 			latex = '\\upshape',
32 | 			css = 'font-style: normal;',
33 | 		},
34 | 		italics = {
35 | 			latex = '\\itshape',
36 | 			css = 'font-style: italic;',
37 | 		},
38 | 		smallcaps = {
39 | 			latex = '\\scshape',
40 | 			css = 'font-variant: small-caps;',
41 | 		},
42 | 		bold = {
43 | 			latex = '\\bfseries',
44 | 			css = 'font-weight: bold;',
45 | 		},
46 | 		normal = {
47 | 			latex = '\\normalfont',
48 | 			css = 'font-style: normal; font-weight: normal; font-variant:normal;'
49 | 		}
50 | 	}
51 | 	-- provide some aliases
52 | 	local ALIASES = {
53 | 		italics = {'italic'},
54 | 		normal = {'normalfont'},
55 | 		smallcaps = {'small%-caps'}, -- used as a pattern, so `-` must be escaped
56 | 	}
57 | 
58 | 	for feature,definition in pairs(FEATURES) do
59 | 		if str:match(feature) and definition[format] then
60 | 			result = result..definition[format]
61 | 		-- avoid multiple copies by only looking for aliases
62 | 		-- if main feature key not found and breaking if we find any alias 
63 | 		elseif ALIASES[feature] then 
64 | 			for _,alias in ipairs(ALIASES[feature]) do
65 | 				if str:match(alias) and definition[format] then
66 | 					result = result..definition[format]
67 | 					break -- ensures no multiple copies
68 | 				end
69 | 			end
70 | 		end
71 | 	end
72 | 
73 | 	return result
74 | 
75 | end
76 | 


--------------------------------------------------------------------------------
/src/Setup.increment_counter.lua:
--------------------------------------------------------------------------------
 1 | ---Setup:increment_counter: increment the counter of a level
 2 | -- Increments a level's counter and reset any statement
 3 | -- count that is counted within that level.
 4 | -- Reset the lower counters to 0 or their --number-offset value
 5 | -- (Mirroring Pandoc's `--number-offset` behaviour
 6 | -- The counters table tells us which statement counters to reset.
 7 | --@param level number, the level to be incremented
 8 | function Setup:increment_counter(level)
 9 | 	if self.counters[level] then
10 | 
11 | 		self.counters[level].count = self.counters[level].count + 1
12 | 
13 | 		if self.counters[level].reset then
14 | 			for _,kind_key in ipairs(self.counters[level].reset) do
15 | 				self.kinds[kind_key].count = 0
16 | 			end
17 | 		end
18 | 
19 | 		for i = level + 1, 6 do
20 | 			if self.counters[i] then
21 | 				self.counters[i].count = PANDOC_WRITER_OPTIONS.number_offset[i]
22 | 																	or 0
23 | 			end
24 | 		end
25 | 
26 | 	end
27 | end
28 | 


--------------------------------------------------------------------------------
/src/Setup.read_options.lua:
--------------------------------------------------------------------------------
  1 | --- Setup:read_options: read user options into the Setup.options table
  2 | --@param meta pandoc Meta object, document's metadata
  3 | --@return nil sets the Setup.options table
  4 | function Setup:read_options(meta) 
  5 | 
  6 | 	-- user-defined localisations.
  7 | 	-- Ready any user-provided translation map in 'stateemnt-locale' or 'locale'
  8 | 	if meta['statement-locale'] or meta.locale then
  9 | 
 10 | 		local function set_locale(lang,map)
 11 | 			if type(map) ~= 'table' then 
 12 | 				return
 13 | 			end
 14 | 			local lang_str = stringify(lang):lower():gsub('-','_')
 15 | 			if not self.LOCALE[lang_str] then 
 16 | 				self.LOCALE[lang_str] = {}
 17 | 			end
 18 | 			for key,translation in pairs(map) do
 19 | 				if type(translation) == 'string' 
 20 | 						or type(translation) == 'Inlines' then
 21 | 					self.LOCALE[lang_str][key] = translation
 22 | 				end
 23 | 			end
 24 | 		end
 25 | 
 26 | 		if meta.locale and type(meta.locale) == 'table' then
 27 | 			for lang,map in pairs(meta.locale) do
 28 | 				set_locale(lang,map)
 29 | 			end
 30 | 		end
 31 | 		if meta['statement-locale'] 
 32 | 				and type(meta['statement-locale']) == 'table' then
 33 | 			for lang,map in pairs(meta['statement-locale']) do
 34 | 				set_locale(lang,map)
 35 | 			end
 36 | 		end
 37 | 
 38 | 	end
 39 | 
 40 | 	-- language. Set language if we have a self.LOCALE value for it
 41 | 	if meta.lang then
 42 | 		-- change the language only if we have a self.LOCALE value for it
 43 | 		-- in the LOCALE table languages are encoded zh_CN rather than zh-CN
 44 | 		-- try the first two letters too
 45 | 		local lang_str = stringify(meta.lang):lower():gsub('-','_')
 46 | 		if self.LOCALE[lang_str] then
 47 | 			self.options.language = lang_str
 48 | 		elseif self.LOCALE[lang_str:sub(1,2)] then
 49 | 			self.options.language = lang_str:sub(1,2)
 50 | 		elseif self.LOCALE['en'] then
 51 | 			self.options.language = 'en'
 52 | 		else
 53 | 			for lang_key,_ in pairs(self.LOCALE) do
 54 | 				self.options.language = lang_key
 55 | 				break
 56 | 			end
 57 | 			if lang_key then 
 58 | 				message('ERROR', 'No translations for language '..lang_str..'.'
 59 | 												 ..' English not available either.'
 60 | 												 .." I've randomly picked `"..self.options.language..'`'
 61 | 												 ..'instead.')
 62 | 			else
 63 | 				message('ERROR', 'Translation table LOCALE is empty, the filter will crash.')
 64 | 			end
 65 | 		end
 66 | 	end
 67 | 
 68 | 	-- pick the document fontsize, needed to convert some lengths
 69 | 	if meta.fontsize then
 70 | 		local fontstr = stringify(meta.fontsize)
 71 | 		local size, unit = fontstr:match('(%d*.%d*)(.*)')
 72 | 		if tonumber(size) then
 73 | 			unit = unit:gsub("%s+", "")
 74 | 			self.options.fontsize = {tonumber(size), unit}
 75 | 		end
 76 | 	end
 77 | 
 78 | 	-- determine which level corresponds to LaTeX's 'section'
 79 | 	self.LaTeX_section_level = self:set_LaTeX_section_level(meta)
 80 | 
 81 | 	if meta.statement then
 82 | 
 83 | 		-- read boolean options
 84 | 		local boolean_options = {
 85 | 			amsthm = 'amsthm',
 86 | 			aliases = 'aliases',
 87 | 			acronyms = 'acronyms',
 88 | 			swap_numbers = 'swap-numbers',
 89 | 			supply_header = 'supply-header',
 90 | 			only_statement = 'only-statement',
 91 | 			define_in_header = 'define-in-header',
 92 | 			citations = 'citations',
 93 | 			pandoc_amsthm = 'pandoc-amsthm',
 94 | 		}
 95 | 		for key,option in pairs(boolean_options) do
 96 | 			if type(meta.statement[option]) == 'boolean' then
 97 | 				self.options[key] = meta.statement[option]
 98 | 			end
 99 | 		end
100 | 
101 | 		-- read count-within option, level or LaTeX level name
102 | 		-- two locations:
103 | 		-- (1) pandoc-amsthm style options, in amsthm: counter_depth (number)
104 | 		-- (2) statement:count-within
105 | 		-- The latter prevails.
106 | 		if self.options.pandoc_amsthm and meta.amsthm 
107 | 				and meta.amsthm.counter_depth then
108 | 			local count_within = tonumber(stringify(meta.amsthm.counter_depth))
109 | 			if self:get_LaTeX_name_by_level(count_within) then
110 | 				self.options.count_within = count_within
111 | 			end
112 | 		end
113 | 		if meta.statement['count-within'] then
114 | 			local count_within = stringify(meta.statement['count-within']):lower()
115 | 			if self:get_level_by_LaTeX_name(count_within) then
116 | 				self.options.count_within = count_within
117 | 			elseif self:get_LaTeX_name_by_level(count_within) then
118 | 				self.options.count_within = count_within
119 | 			end
120 | 		end
121 | 
122 | 	end -- end of `meta.statement` processing
123 | 
124 | 
125 | end


--------------------------------------------------------------------------------
/src/Setup.set_kind.lua:
--------------------------------------------------------------------------------
  1 | ---Setup:set_kind: create or set a kind based on an options map
  2 | -- Creates a new style or modify an existing one, based on options.
  3 | --@param kind string kind key
  4 | --@param map table, kind definition from user metadata
  5 | --@param new_kinds table (optional), new kinds to be defined
  6 | function Setup:set_kind(kind,map,new_kinds)
  7 | 	local styles = self.styles -- points to the styles map
  8 | 	local kinds = self.kinds -- points to the kinds map
  9 | 	local map = map or {}
 10 | 	local new_kind = {}
 11 | 
 12 | 	-- if kind already defined, get original fields
 13 | 	if kinds[kind] then
 14 | 		new_kind = kinds[kind]
 15 | 	end
 16 | 
 17 | 	-- Ensure kind has a valid counter
 18 | 	-- if shared counter, check that it exists or is about to be defined
 19 | 	if map.counter then
 20 | 		local counter = stringify(map.counter)
 21 | 		if counter == 'self' or counter == 'none' then
 22 | 			new_kind.counter = counter
 23 | 		elseif counter == kind then -- using own name as counter
 24 | 			new_kind.counter = 'self'
 25 | 		elseif self:get_level_by_LaTeX_name(counter) then -- latex counter
 26 | 			new_kind.counter = counter
 27 | 		elseif self:get_LaTeX_name_by_level(counter) then -- level counter
 28 | 			new_kind.counter = counter
 29 | 		elseif kinds[counter] or new_kinds and new_kinds[counter] then
 30 | 			new_kind.counter = counter
 31 | 		else
 32 | 			message('ERROR', 'Cannot understand counter setting `'..counter
 33 | 											..'` to define statement kind '..kind..'.')
 34 | 		end
 35 | 	end
 36 | 	-- if no counter, use the pre-existing counter if there's one
 37 | 	-- otherwise use the first primary counter found in `kinds`
 38 | 	-- or `options.count_within` or `self`	
 39 | 	if not map.counter then
 40 | 		if not new_kind.counter then
 41 | 			for kind,definition in pairs(kinds) do
 42 | 				if definition.counter == 'self'
 43 | 					or self:get_level_by_LaTeX_name(definition.counter) 
 44 | 					or self:get_LaTeX_name_by_level(definition.counter) then
 45 | 						new_kind.counter = kind
 46 | 						break
 47 | 				end
 48 | 			end
 49 | 		end
 50 | 		if not new_kind.counter then
 51 | 			new_kind.counter = self.options.count_within or 'self'
 52 | 		end
 53 | 	end
 54 | 
 55 | 	-- validate the kind's style
 56 | 	-- if none (or bad) provided, use 'plain' or 'empty'
 57 | 	if map.style then
 58 | 		map.style = stringify(map.style)
 59 | 	 	if styles[map.style] then
 60 | 			new_kind.style = map.style
 61 | 		else
 62 | 			message('ERROR', 'Style `'.. map.style 
 63 | 											..'` for statement kind `'..kind
 64 | 											..'` is not defined.')
 65 | 		end
 66 | 	end
 67 | 	if not map.style then 
 68 | 		if styles['plain'] then
 69 | 			new_kind.style = 'plain'
 70 | 		elseif styles['empty'] then
 71 | 			new_kind.style = 'empty'
 72 | 		else -- use any style you can find!
 73 | 			for style_key,_ in pairs(styles) do
 74 | 				new_kind.style = style_key
 75 | 				break
 76 | 			end
 77 | 		end
 78 | 		if new_kind.style then
 79 | 			message('INFO', 'Statement kind `'..kind..'`'
 80 | 											..' has not been given a style.'
 81 | 											..' Using `'..new_kind.style..'`.')
 82 | 		else
 83 | 			message('ERROR','Defaults misconfigured:'
 84 | 													..'no `empty` style provided.')
 85 | 			new_kind.style = 'empty' -- may still work e.g. in HTML
 86 | 		end
 87 | 	end
 88 | 
 89 | 	-- validate and insert options
 90 | 	local string_fields = { 
 91 | 		'prefix', 
 92 | 	}
 93 | 	local inlines_fields = {
 94 | 		'label'
 95 | 	}
 96 | 	local strings_list_fields = {
 97 | 		'aliases',
 98 | 	}
 99 | 	local map_fields = {
100 | 		'custom_label_style'
101 | 	}
102 | 	for _,string_field in ipairs(string_fields) do
103 | 		if map[string_field] then
104 | 			new_kind[string_field] = stringify(map[string_field])
105 | 		end
106 | 	end
107 | 	for _,inlines_field in ipairs(inlines_fields) do
108 | 		if map[inlines_field] then
109 | 			if type(map[inlines_field]) == 'Inlines' then
110 | 				new_kind[inlines_field] = map[inlines_field]
111 | 			else
112 | 				new_kind[inlines_field] = pandoc.Inlines(pandoc.Str(
113 | 																		stringify(map[inlines_field])
114 | 																	))
115 | 			end
116 | 		end
117 | 	end
118 | 	for _,strings_list_field in ipairs(strings_list_fields) do
119 | 		if map[strings_list_field] then
120 | 			if type(map[strings_list_field]) == 'List' then
121 | 				new_kind[strings_list_field] = map[strings_list_field]
122 | 			elseif type(map[strings_list_field]) == 'string' 
123 | 					or type(map[strings_list_field]) == 'Inlines' then
124 | 				new_kind[strings_list_field] = pandoc.List:new(
125 | 																		{stringify(map[strings_list_field])}
126 | 																	)
127 | 			end
128 | 		end
129 | 	end
130 | 	for _,map_field in ipairs(map_fields) do
131 | 		if map[map_field] then
132 | 			new_kind[map_field] = map[map_field]
133 | 		end
134 | 	end
135 | 
136 | 	-- store in kinds table
137 | 	kinds[kind] = new_kind
138 | 
139 | end


--------------------------------------------------------------------------------
/src/Setup.set_style.lua:
--------------------------------------------------------------------------------
  1 | ---Setup:set_style: create or set a style based on an options map
  2 | -- Creates a new style or modify an existing one, based on options.
  3 | --@param name string style key
  4 | --@param map table style definition from user metadata
  5 | --@param new_styles table map of new styles to be defined
  6 | function Setup:set_style(style,map,new_styles)
  7 | 	local styles = self.styles -- points to the styles map
  8 | 	local length_format = Helpers.length_format
  9 | 	local font_format = Helpers.length_format
 10 | 	local map = map or {}
 11 | 	local new_style = {}
 12 | 	local based_on = map.based_on and stringify(map.based_on) or nil
 13 | 
 14 | 	---merge_valid_options: build a map of valid options
 15 | 	-- from a main map and basis map.
 16 | 	-- we'll apply this to the main map but also
 17 | 	-- to the `custom_label_changes` submap.
 18 | 	--@param map, table or nil the values explicitly specified
 19 | 	--@param basis, table or nil the based_on backup values
 20 | 	local function merge_valid_options(map,basis)
 21 | 		local new_map = {}
 22 | 		-- length fields: not that `space_after_head` is added below if needed
 23 | 		local length_fields = pandoc.List:new({
 24 | 			'margin_top', 'margin_bottom', 'margin_left', 'margin_right',
 25 | 			'indent',
 26 | 		})
 27 | 		-- Note: keeping font fields separate in case we wanted to validate them.
 28 | 		-- Presently no validation, they are treated like string fields.
 29 | 		local font_fields = {
 30 | 			'body_font', 'head_font', 'crossref_font',
 31 | 		}
 32 | 		local string_fields = { 
 33 | 			'punctuation', 'heading_pattern'
 34 | 		}
 35 | 
 36 | 		-- handles linebreak_after_head style
 37 | 		-- (a) linebreak_after_head already is set: ignore space_after_head
 38 | 		-- (b) space_after_head is \n or \newline: set linebreak_after_head
 39 | 		-- (c) otherwise, read space_after_head as a length
 40 | 		-- special case: space_after_head can be `\n` or `\\n` or `\\newline`
 41 | 		-- if not, assume it's a length
 42 | 		if map and map.linebreak_after_head 
 43 | 				or basis and basis.linebreak_after_head then
 44 | 			new_map.linebreak_after_head = true		
 45 | 		elseif map and map.space_after_head and
 46 | 				(map.space_after_head == 
 47 | 								pandoc.MetaInlines(pandoc.RawInline('tex', '\\n'))
 48 | 					or map.space_after_head == 
 49 | 								pandoc.MetaInlines(pandoc.RawInline('tex', '\\newline'))
 50 | 					or map.space_after_head == 
 51 | 								pandoc.MetaInlines(pandoc.RawInline('latex', '\\n'))
 52 | 					or map.space_after_head == 
 53 | 								pandoc.MetaInlines(pandoc.RawInline('latex', '\\newline'))
 54 | 				) then
 55 | 			new_map.linebreak_after_head = true
 56 | 		else
 57 | 			length_fields:insert('space_after_head')
 58 | 		end
 59 | 
 60 | 		-- insert fields
 61 | 		for _,length_field in ipairs(length_fields) do
 62 | 			new_map[length_field] = (map and map[length_field] 
 63 | 																and length_format(map[length_field])
 64 | 																and stringify(map[length_field]))
 65 | 																or basis and basis[length_field]
 66 | 		end
 67 | 		for _,font_field in ipairs(font_fields) do
 68 | 			new_map[font_field] = map and map[font_field]
 69 | 															and stringify(map[font_field])
 70 | 															or basis and basis[font_field]
 71 | 		end
 72 | 		for _,string_field in ipairs(string_fields) do
 73 | 			new_map[string_field] = map and map[string_field] 
 74 | 																and stringify(map[string_field])
 75 | 																or basis and basis[string_field]
 76 | 		end
 77 | 
 78 | 		return new_map
 79 | 
 80 | 	end
 81 | 
 82 | 	-- MAIN FUNCTION BODY
 83 | 
 84 | 	-- determine the style's basis: 
 85 | 	--	(1) user-defined basis, or 
 86 | 	--	(2) default version of this style if any,
 87 | 	--	(3) otherwise 'plain', otherwise 'empty'
 88 | 	-- user-defined basis may be one of the new styles to be defined
 89 | 	if based_on then
 90 | 		if styles[based_on] or 	new_styles and new_styles[based_on]
 91 | 														and based_on ~= style then
 92 | 			-- leave based_on as is
 93 | 		elseif based_on == style then
 94 | 			message('ERROR', 'Style '..style..' defined to be based on itself.'
 95 | 								..'This is only allowed if defaults provide this style.')
 96 | 			based_on = nil
 97 | 		else
 98 | 			message('ERROR', 'Style '..style..' could not be based on'
 99 | 												..'`'..based_on..'`. Check if the latter'
100 | 												..' is defined.')
101 | 			based_on = nil
102 | 		end
103 | 	end
104 | 	if not based_on then 
105 |  		if styles[style] then
106 | 			based_on = style
107 | 		elseif styles['plain'] then
108 | 			based_on = 'plain'
109 | 		elseif styles['empty'] then
110 | 			based_on = 'empty'
111 | 		else
112 | 			message('ERROR','Filter defaults misconfigured:'
113 | 				..' no `empty` style provided.'
114 | 				..' Definition for '..style..' must be complete.'
115 | 				.." If it isn't things may break.")
116 | 		end
117 | 	end
118 | 
119 | 	-- read do_not_define_in_FORMAT fields 
120 | 	for key,value in pairs(map) do
121 | 		if key:match('^do_not_define_in_') then
122 | 			new_style[key] = stringify(value)
123 | 		end
124 | 	end
125 | 
126 | 	-- create the custom_label_changes map
127 | 	if map.custom_label_changes 
128 | 			or styles[based_on].custom_label_changes then
129 | 		new_style.custom_label_changes = 
130 | 					merge_valid_options(map.custom_label_changes, 
131 | 															styles[based_on].custom_label_changes)
132 | 	end
133 | 
134 | 	-- merge remaining options
135 | 	local merge = merge_valid_options(map, styles[based_on])
136 | 	for k,v in pairs(merge) do
137 | 		new_style[k] = v
138 | 	end 
139 | 
140 | 	-- Special checks to avoid LaTeX crashes
141 | 	if not new_style.space_after_head 
142 | 		or new_style.space_after_head == '' then
143 | 			new_style.space_after_head = '0pt'
144 | 	end
145 | 
146 | 	-- store the result
147 | 	styles[style] = new_style
148 | 
149 | end


--------------------------------------------------------------------------------
/src/Setup.update_meta.lua:
--------------------------------------------------------------------------------
 1 | ---Setup:update_meta: update a document's metadata
 2 | -- inserts the setup.includes.header in the document's metadata
 3 | --@param meta Pandoc Meta object
 4 | --@return meta Pandoc Meta object
 5 | function Setup:update_meta(meta)
 6 | 
 7 | 	if self.options.supply_header and self.includes.header then
 8 | 
 9 | 		if meta['header-includes'] then
10 | 
11 | 			if type(meta['header-includes']) == 'List' then
12 | 				meta['header-includes']:extend(self.includes.header)
13 | 			else
14 | 				self.includes.header:insert(1, meta['header-includes'])
15 | 				meta['header-includes'] = self.includes.header
16 | 			end
17 | 
18 | 		else
19 | 
20 | 			meta['header-includes'] = self.includes.header
21 | 
22 | 		end
23 | 
24 | 	end
25 | 
26 | 	return meta
27 | 
28 | end
29 | 
30 | 


--------------------------------------------------------------------------------
/src/Setup.validate_defaults.lua:
--------------------------------------------------------------------------------
 1 | ---Setup:validate_defaults: check that the filter's DEFAULTS are
 2 | -- well configured. Prints an error if not.
 3 | function Setup:validate_defaults()
 4 | 	local default_keys = pandoc.List:new() -- list of DEFAULTS.KINDS keys
 5 | 	local valid = true
 6 | 
 7 | 	-- check that we have 'none' defaults and that they provide 'statement'
 8 | 	if not self.DEFAULTS.KINDS.none then
 9 | 		message('ERROR', 'DEFAULTS file misconfigured: `none` defaults set missing in KINDS.')
10 | 		valid = false
11 | 	elseif not self.DEFAULTS.KINDS.none.statement then
12 | 		message('ERROR', 'DEFAULTS file misconfigured: `none` defaults lack the `statement` kind.')
13 | 		valid = false
14 | 	elseif not self.DEFAULTS.KINDS.none.statement.style then
15 | 		message('ERROR', 'DEFAULTS file misconfigured: `none.statement` has no style setting.')
16 | 		valid = false
17 | 	elseif not self.DEFAULTS.STYLES.none 
18 | 					or not self.DEFAULTS.STYLES.none[self.DEFAULTS.KINDS.none.statement.style] then
19 | 		message('ERROR', 'DEFAULTS file misconfigured: the none.statement style, '
20 | 										..self.DEFAULTS.KINDS.none.statement.style
21 | 										..' should be present in the STYLES.none table.')
22 | 		valid = false
23 | 	end
24 | 	if not self.DEFAULTS.STYLES.none then
25 | 		message('ERROR', 'DEFAULTS file misconfigured: `none` defaults set missing in STYLES.')
26 | 		valid = false
27 | 	end
28 | 
29 | 	-- check that each default set has both kinds and styles
30 | 	for set,_ in pairs(self.DEFAULTS.KINDS) do
31 | 		if not self.DEFAULTS.STYLES[set] then
32 | 			message('ERROR', 'DEFAULTS file misconfigured: no `'
33 | 				..set..'` defaults in the STYLES table.')
34 | 			valid = false
35 | 		end
36 | 	end
37 | 
38 | 	-- check that each kind has a counter and an existing style
39 | 	for set,_ in pairs(self.DEFAULTS.KINDS) do
40 | 		for kind,definition in pairs(self.DEFAULTS.KINDS[set]) do
41 | 			if not definition.counter then 
42 | 				message('ERROR', 'DEFAULTS file misconfigured: kind `'..kind..'`'
43 | 												..' in default set `'..set..'` has no counter.')
44 | 				valid = false
45 | 			end
46 | 			if not definition.style then 
47 | 				message('ERROR', 'DEFAULTS file misconfigured: kind `'..kind..'`'
48 | 												..' in default set `'..set..'` has no style.')
49 | 				valid = false
50 | 			end
51 | 			if not self.DEFAULTS.STYLES[set][definition.style] then 
52 | 				message('ERROR', 'DEFAULTS file misconfigured: style `'..definition.style..'`'
53 | 												..' needed by kind `'..kind..'` is missing in STYLES.'..set..'.')
54 | 				valid = false
55 | 			end
56 | 			if self.options and self.options.language
57 | 				and not self.LOCALE[self.options.language][kind] then
58 | 					message('WARNING', 'LOCALE file, entry `'..self.options.language..'`'
59 | 								.."doesn't provide a label for the kind `"..kind..'`'
60 | 								..' in defaults set `'..set..'`.')
61 | 				valid = false
62 | 			end
63 | 		end
64 | 	end
65 | 
66 | 	if valid then
67 | 		message('INFO', 'Defaults files checked, all is in order.')
68 | 	end
69 | 
70 | end


--------------------------------------------------------------------------------
/src/Setup.write_counter.lua:
--------------------------------------------------------------------------------
 1 | --- Setup:write_counter: format a counter as string
 2 | --@param level number, counter level
 3 | --@return string formatted counter
 4 | function Setup:write_counter(level)
 5 | 
 6 | 	-- counter_format: function to be used in recursion
 7 | 	-- The recursion list tracks the levels encountered in recursion
 8 | 	-- to ensure the function doesn't get into an infinite loop.
 9 | 	local function counter_format(lvl, recursion)
10 | 		local recursion = recursion or pandoc.List:new()
11 | 		local result = ''
12 | 
13 | 		if not self.counters[lvl] then
14 | 			message('WARNING', 'No counter for lvl '..tostring(lvl)..'.')
15 | 			result = '??'
16 | 		else
17 | 			result = self.counters[lvl].format or '%s'
18 | 			-- remember that we're currently processing this lvl
19 | 			recursion:insert(lvl)
20 | 			-- replace %s by the value of this counter
21 | 			local self_count = self.counters[lvl].count or 0
22 | 			result = result:gsub('%%s', tostring(self_count))
23 | 			-- replace %p by the formatted previous lvl counter
24 | 			-- unless we're already processing that lvl in recursion
25 | 			if lvl > 1 and not recursion:find(lvl-1) then
26 | 				result = result:gsub('%%p',counter_format(lvl-1, recursion))
27 | 			end
28 | 			-- replace %1, %2, ... by the value of the corresponding counter
29 | 			-- unless we're already processing them in recursion
30 | 			for i = 1, 6 do
31 | 				if result:match('%%'..tostring(i)) and not recursion:find(i) then
32 | 					result = result:gsub('%%'..tostring(i), 
33 | 																counter_format(i, recursion))
34 | 				end
35 | 			end
36 | 		end
37 | 
38 | 		return result
39 | 
40 | 	end
41 | 
42 | 	return counter_format(level)
43 | 
44 | end


--------------------------------------------------------------------------------
/src/Statement.DefListitem_is_statement.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:DefListitem_is_statement: whether a DefinitionList item 
 2 | -- is a statement. If yes, returns the kind it matches.
 3 | -- An item is a statement if its defined expression starts
 4 | -- with a Str element whose text matches a statement kind (or alias).
 5 | --@param elem (optional) item of a pandoc DefinitionList,
 6 | --							defaults to self.element[1]
 7 | --@param setup (optional) a Setup class object, to be used when
 8 | --			the function is called from the setup object
 9 | --@return string or nil element's kind (key of `setup.kinds`) or nil
10 | function Statement:DefListitem_is_statement(item, setup)
11 | 	setup = setup or self.setup -- pointer to the setup table
12 | 	local kinds = setup.kinds -- pointer to the kinds table
13 | 	item = item or self.element 
14 | 									and self.element.t == 'DefinitionList' 
15 | 									and self.element.content[1]
16 | 	local expression -- Inlines expression defined, i.e. item[1]
17 | 	local kind -- kind key, if found
18 | 	--local new_item -- modified item
19 | 
20 | 	expression = item[1]
21 | 	if expression[1].t and expression[1].t == 'Str' then
22 | 
23 | 		-- ignore any dot at the end of the string
24 | 		local str = expression[1].text:match('(.+)%.$') or expression[1].text
25 | 		-- try a key match, return
26 | 	  return self:is_kind_key(str, setup)
27 | 
28 | 	end
29 | 
30 | end
31 | 


--------------------------------------------------------------------------------
/src/Statement.Div_is_statement.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:Div_is_statement Whether an Div element is a statement.
 2 | -- If yes, returns a list of kinds the element matches.
 3 | --@param elem (optional) pandoc Div element, defaults to self.element
 4 | --@param setup (optional) a Setup class object, to be used when
 5 | --			the function is called from the setup object
 6 | --@return List or nil, pandoc List of kinds the element matches
 7 | function Statement:Div_is_statement(elem,setup)
 8 | 	setup = setup or self.setup
 9 | 	elem = elem or self.element
10 | 	local options = setup.options -- pointer to the options table
11 | 	local kinds = setup.kinds -- pointer to the kinds table
12 | 
13 | 	-- safety check
14 | 	if not elem.t or elem.t ~= 'Div' then
15 | 		message('ERROR', 	'Non-Div element passed to the Div_is_statement function,'
16 | 											..' this should not have happened.')
17 | 		return
18 | 	end
19 | 
20 | 	-- collect the element's classes that match a statement kind
21 | 	-- check aliases if `options.aliases` is true
22 | 	local matches = pandoc.List:new()
23 | 	for _,class in ipairs(elem.classes) do
24 | 		-- nb, needs to pass the setup to is_kind_key 
25 | 		-- in case the statement isn't created yet
26 | 		local kind_key = self:is_kind_key(class, setup)
27 | 		-- if found, add provided it's not a duplicate
28 | 		if kind_key and not matches:find(kind_key) then
29 | 			matches:insert(kind_key)
30 | 		end
31 | 	end
32 | 
33 | 	-- fail if no match, or if the options require every statement to
34 | 	-- have the `statement` kind and we don't have it. 
35 | 	-- if success, remove the statement kind if we have another kind as well.
36 | 	if #matches == 0 
37 | 		or (options.only_statement and not matches:find('statement')) then
38 | 			return nil
39 | 	else
40 | 		if #matches > 1 and matches:includes('statement') then
41 | 			local _, pos = matches:find('statement')
42 | 			matches:remove(pos)
43 | 		end
44 | 		return matches
45 | 	end
46 | 
47 | end


--------------------------------------------------------------------------------
/src/Statement.extract_fbb.lua:
--------------------------------------------------------------------------------
  1 | --- Statement:extract_fbb: extract the first content found between 
  2 | -- balanced brackets from an Inlines list, searching forward or 
  3 | -- backwards. Returns that content and the reminder, or nil and the 
  4 | -- original content.
  5 | -- @param inlines an Inlines list
  6 | -- @param direction string, 'reverse' or 'forward' search direction
  7 | -- @param delimiters table of beginning and ending delimiters, 
  8 | --		e.g. {'[',']'} for square brackets. Defaults to {'(',')'}
  9 | -- @return bracketed Inlines, Inlines bracketed content found, or nil
 10 | -- @return remainder Inlines, remainder of the content after extraction,
 11 | -- 		or all the content if nothing has been found.
 12 | function Statement:extract_fbb(inlines, direction, delimiters)
 13 | 
 14 | 	-- check and load parameters
 15 | 	local bb, eb = '(', ')'
 16 | 	local reverse = false
 17 | 	if type(inlines) ~= 'Inlines' or #inlines == 0 then
 18 | 		return nil, inlines
 19 | 	end
 20 | 	if direction == 'reverse' then reverse = true end
 21 | 	if delimiters and type(delimiters) == 'table' 
 22 | 		and #delimiters == 2 then
 23 | 			bb, eb = delimiters[1], delimiters[2]
 24 | 	end
 25 | 	-- in reverse mode swap around open and closing delimiters
 26 | 	if reverse then
 27 | 		bb, eb = eb, bb
 28 | 	end
 29 | 
 30 | 	-- functions to accomodate the direction of processing
 31 | 	function first_pos(list)
 32 | 		return reverse and #list or 1
 33 | 	end
 34 | 	function last_pos(list)
 35 | 		return reverse and 1 or #list
 36 | 	end
 37 | 	function insert_last(list, item)
 38 | 		if reverse then list:insert(1, item) else list:insert(item) end
 39 | 	end
 40 | 	function insert_first(list, item)
 41 | 		if reverse then list:insert(item) else list:insert(1, item) end
 42 | 	end
 43 | 	function first_item(list) 
 44 | 		return list[first_pos(list)]
 45 | 	end
 46 | 	function first_char(s)
 47 | 		return reverse and s:sub(-1,-1) or s:sub(1,1)
 48 | 	end
 49 | 	function all_but_first_char(s)
 50 | 		return reverse and s:sub(1,-2) or s:sub(2,-1)
 51 | 	end
 52 | 	function append_to_str(s, ch)
 53 | 		return reverse and ch..s or s..ch
 54 | 	end
 55 | 
 56 | 	-- prepare return values
 57 | 	local bracketed, rest = pandoc.List:new(), inlines:clone()
 58 | 
 59 | 	-- check that we start (end, in reverse mode) 
 60 | 	-- with a beginning delimiter. If yes remove it
 61 | 	if first_item(rest).t ~= 'Str' 
 62 | 		or first_char(first_item(rest).text) ~= bb then
 63 | 			return nil, inlines
 64 | 	else
 65 | 		-- remove the delimiter. special case: Str is just the delimiter
 66 | 		if first_item(rest).text == bb then
 67 | 			rest:remove(first_pos(rest))
 68 | 			-- remove leading/trailing space after bracket if needed
 69 | 			if first_item(rest).t == 'Space' then
 70 | 				rest:remove(first_pos(rest))
 71 | 			end
 72 | 		else -- standard case, bracket is just the first char of Str
 73 | 			first_item(rest).text = all_but_first_char(
 74 | 										first_item(rest).text)
 75 | 		end
 76 | 	end
 77 | 
 78 | 	-- loop to go through all Str elements and find the balanced
 79 | 	-- closing bracket
 80 | 	local nb_brackets = 1
 81 | 
 82 | 	while nb_brackets > 0 and #rest > 0 do
 83 | 
 84 | 		-- extract first element
 85 | 		local elem = first_item(rest)
 86 | 		rest:remove(first_pos(rest))
 87 | 
 88 | 		-- non Str elements are just stored in the bracketed content
 89 | 		if elem.t ~= 'Str' then 
 90 | 			insert_last(bracketed, elem)
 91 | 		else
 92 | 		-- Str elements: scan for brackets
 93 | 
 94 | 			local str = elem.text
 95 | 			local bracketed_part, outside_part = '', ''
 96 | 			while str:len() > 0 do
 97 | 
 98 | 				-- extract first char
 99 | 				local char = first_char(str)
100 | 				str = all_but_first_char(str)
101 | 
102 | 				-- have we found the closing bracket? if yes,
103 | 				-- store the reminder of the string without the bracket.
104 | 				-- if no, change the bracket count if needed and add the
105 | 				-- char to bracketed material
106 | 				if char == eb and nb_brackets == 1 then
107 | 					nb_brackets = 0
108 | 					outside_part = str
109 | 					break
110 | 				else
111 | 					if char == bb then
112 | 						nb_brackets = nb_brackets + 1
113 | 					elseif char == eb then
114 | 						nb_brackets = nb_brackets -1
115 | 					end
116 | 					bracketed_part = append_to_str(bracketed_part, char)
117 | 				end
118 | 			end
119 | 
120 | 			-- store the bracketed part
121 | 			if bracketed_part:len() > 0 then
122 | 				insert_last(bracketed, pandoc.Str(bracketed_part))
123 | 			end
124 | 			-- if there is a part outside of the brackets,
125 | 			-- re-insert it in rest
126 | 			if outside_part:len() > 0 then
127 | 				insert_first(rest, pandoc.Str(outside_part))
128 | 			end
129 | 
130 | 		end
131 | 
132 | 	end
133 | 
134 | 	-- if nb_bracket is down to 0, we've found balanced brackets content,
135 | 	-- otherwise return empty handed
136 | 	if nb_brackets == 0 then
137 | 		return bracketed, rest
138 | 	else
139 | 		return nil, inlines
140 | 	end
141 | 
142 | end
143 | 


--------------------------------------------------------------------------------
/src/Statement.is_kind_key.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:is_kind_key: whether a string is a kind key or an alias.
 2 | -- If yes, return the kind key.
 3 | --@param str string to be tested
 4 | --@param setup (optional) a Setup class object, to be used when
 5 | --			the function is called from the setup object
 6 | --@return kind_key string a key of the kinds table
 7 | function Statement:is_kind_key(str, setup)
 8 | 	setup = setup or self.setup
 9 | 	local kinds = setup.kinds -- points to the kinds table
10 | 	local options = setup.options -- points to the options table
11 | 	local aliases = setup.aliases -- pointed to the aliases table
12 | 
13 | 	-- safety check
14 | 	if type(str) ~= 'string' then
15 | 		message('ERROR', 'Testing whether a non-string is a kind key.'
16 | 											.. 'This should not have happened.')
17 | 		return
18 | 	end
19 | 
20 | 	if kinds[str] then
21 | 		return str
22 | 	else
23 | 		-- try lowercase match, 
24 | 		-- and aliases that are all lowercase
25 | 		str = str:lower()
26 | 		if kinds[str] then
27 | 			return str
28 | 		elseif aliases[str] then
29 | 			return aliases[str]
30 | 		end
31 | 	end
32 | 
33 | end
34 | 


--------------------------------------------------------------------------------
/src/Statement.is_statement.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:is_statement Whether an element is a statement.
 2 | -- Simple wrapper for the Div_is_statement and 
 3 | -- DefinitionList_is_statement functions.
 4 | --@param elem pandoc element, should be Div or DefinitionList
 5 | --@param setup (optional) a Setup class object, to be used when
 6 | --			the function is called from the setup object
 7 | --@return list or nil, pandoc List of kinds matched
 8 | function Statement:is_statement(elem,setup)
 9 | 	setup = setup or self.setup
10 | 	if elem.t then
11 | 		if elem.t == 'Div' then
12 | 			return self:Div_is_statement(elem,setup)
13 | 		elseif elem.t == 'DefinitionList' 
14 | 					and elem.content[1] then
15 | 			return self:DefListitem_is_statement(elem.content[1],setup)
16 | 		end
17 | 	end
18 | end


--------------------------------------------------------------------------------
/src/Statement.lua:
--------------------------------------------------------------------------------
  1 | -- # Statement class
  2 | 
  3 | --- Statement: class for statement objects.
  4 | Statement = {
  5 | 	element = nil, -- original element to be turned into statement
  6 | 	kind = nil, -- string, key of `kinds`
  7 | 	identifier = nil, -- string, Pandoc identifier
  8 | 	custom_label = nil, -- Inlines, user-provided label
  9 | 	crossref_label = nil, -- Inlines, label used to crossreference the statement
 10 | 	label = nil, -- Inlines, label to display in non-LaTeX format e.g. "Theorem 1.1"
 11 | 	acronym = nil, -- Inlines, acronym
 12 | 	info = nil, -- Inlines, user-provided info
 13 | 	content = nil, -- Blocks, statement's content
 14 | 	is_numbered = true, -- whether a statement is numbered
 15 | }
 16 | 
 17 | 
 18 | !input Statement.is_statement -- to tell whether an element is a statement, and what kind it matches
 19 | 
 20 | !input Statement.is_kind_key -- to tell whether a string is a kind key, or the alias of one
 21 | 
 22 | !input Statement.parse_heading_inlines -- parse heading inlines into acronym, custom label, info, remainder
 23 | 
 24 | !input Statement.parse_identifier -- extract label{...} or {#...} identifiers from Inlines
 25 | 
 26 | !input Statement.Div_is_statement -- to tell whether an element is a statement, and what kind it matches
 27 | 
 28 | !input Statement.parse_Div -- parse Div element as statement
 29 | 
 30 | -- !input Statement.parse_Div_heading -- parse Div element as statement
 31 | 
 32 | !input Statement.DefListitem_is_statement -- to tell whether an Definition list item is a statement and of which kind
 33 | 
 34 | !input Statement.parse_DefList -- parse a DefinitionList
 35 | 
 36 | !input Statement.parse_DefList_kind -- extract kind name from a Definition List first item
 37 | 
 38 | !input Statement.extract_fbb -- to extract content between first balanced brackets
 39 | 
 40 | !input Statement.trim_dot_space -- remove leading/trailing dot space in Inlines
 41 | 
 42 | !input Statement.new_kind_from_label -- to create a new kind from the statement's label
 43 | 
 44 | !input Statement.new_kind_unnumbered -- to create a new kind from the statement's label
 45 | 
 46 | !input Statement.set_values -- set a statement's fields, post-parsing
 47 | 
 48 | !input Statement.set_identifier -- to set id and store it
 49 | 
 50 | !input Statement.set_is_numbered -- determine whether statement is numbered
 51 | 
 52 | !input Statement.set_labels -- to set label and crossref label
 53 | 
 54 | !input Statement.set_count -- to update the count of this statement's kind
 55 | 
 56 | !input Statement.write -- to write a statement (main function)
 57 | 
 58 | !input Statement.write_style -- to write a style definition
 59 | 
 60 | !input Statement.write_kind -- to write a kind definition
 61 | 
 62 | !input Statement.write_label -- to write a statement's label
 63 | 
 64 | !input Statement.write_latex -- to write a statement in LaTeX
 65 | 
 66 | !input Statement.write_html -- to write a statement in HTML
 67 | 
 68 | !input Statement.write_jats -- to write a statement in JATS
 69 | 
 70 | !input Statement.write_native -- to write a statement in other formats
 71 | 
 72 | --- create a statement object from a pandoc element.
 73 | -- @param elem pandoc Div or DefinitionList
 74 | -- @param setup Setup class object, the document's statements setup
 75 | -- @return statement object or nil if elem isn't a statement
 76 | function Statement:new(elem, setup)
 77 | 
 78 | 	-- create an object of Statement class
 79 | 	local o = {}
 80 | 	self.__index = self 
 81 | 	setmetatable(o, self)
 82 | 
 83 | 	o.setup = setup -- points to the setup, needed by the class's methods
 84 | 	o.element = elem -- points to the original element
 85 | 
 86 | 	if o.element.t then
 87 | 
 88 | 		if o.element.t == 'Div' and o:Div_is_statement() then
 89 | 			o:parse_Div()
 90 | 			o:set_values()
 91 | 			return o
 92 | 
 93 | 		elseif o.element.t == 'DefinitionList' 
 94 | 						and o.element.content[1]
 95 | 						and o:DefListitem_is_statement(o.element.content[1]) then
 96 | 			o:parse_DefList()
 97 | 			o:set_values()
 98 | 			return o
 99 | 
100 | 		end
101 | 	end
102 | 
103 | end
104 | 


--------------------------------------------------------------------------------
/src/Statement.new_kind_from_label.lua:
--------------------------------------------------------------------------------
 1 | --- Statement:new_kind_from_label: create and set a new kind from a 
 2 | -- statement's custom label. 
 3 | -- Uses:
 4 | --		setup:set_style to create a style based on another
 5 | --		self.kind the statement's kind
 6 | --		self.custom_label the statement's custom label
 7 | -- Updates:
 8 | --		self.setup.kinds
 9 | --		self.setup.styles
10 | --
11 | --@return nil
12 | function Statement:new_kind_from_label()
13 | 	local setup = self.setup -- pointing to the setup
14 | 	local styles = self.setup.styles -- pointer to the styles table
15 | 	local kinds = self.setup.kinds -- pointer to the kinds table	
16 | 	local kind = kind or self.kind -- key of the original statement style
17 | 	local style = kinds[kind].style
18 | 	local custom_label = self.custom_label
19 | 	local new_kind, new_style -- keys of the new statement kind 
20 | 														-- and (if needed) the new style
21 | 
22 | 	-- create_key_from_label: turn inlines into a key that
23 | 	-- can safely be used as LaTeX envt name and html class.
24 | 	-- we go through utf8 chars and only keep ASCII alphanum ones
25 | 	-- we add 'statement_' in case the label matches a LaTeX command
26 | 	local function create_key_from_label(inlines)
27 | 		local result = 'sta_'
28 | 		for _,code in utf8.codes(stringify(inlines)) do
29 | 			if (code >= 48 and code <= 57) -- digits 
30 | 					or (code >= 65 and code <= 90) -- A-Z 
31 | 					or (code >= 97 and code <= 122) then
32 | 				result = result..utf8.char(code):lower()
33 | 			else
34 | 				result = result..'_'
35 | 			end
36 | 		end
37 | 		return result
38 | 	end
39 | 
40 | 	-- Main function body
41 | 
42 | 	if not custom_label then
43 | 		return
44 | 	end
45 | 
46 | 	-- create a new kind key from label
47 | 	local label_str = create_key_from_label(custom_label)
48 | 	-- ensure it's a new key
49 | 	local n = 0
50 | 	new_kind = label_str
51 | 	while kinds[new_kind] do
52 | 		n = n + 1
53 | 		new_kind = label_str..'-'..tostring(n)
54 | 	end
55 | 
56 | 	-- do we need a new style too?
57 | 	-- the style's custom_label_changes field holds
58 | 	-- changes needed when a custom label is used.
59 | 	-- we create a <style>_custom if not already done.
60 | 	if styles[style].custom_label_changes then
61 | 
62 | 		if not styles[style..'_custom'] then
63 | 
64 | 			-- create a modified map of the style
65 | 			local custom_style_map = {}
66 | 			for k,v in pairs(styles[style].custom_label_changes) do
67 | 				custom_style_map[k] = v
68 | 			end
69 | 			for k,v in pairs(styles[style]) do
70 | 				if not custom_style_map[k] then
71 | 					custom_style_map[k] = v
72 | 				end
73 | 			end
74 | 			setup:set_style(style..'_custom', custom_style_map)
75 | 
76 | 		end
77 | 
78 | 		style = style..'_custom'
79 | 
80 | 	end
81 | 
82 | 	-- set the new kind
83 | 	setup:set_kind(new_kind, {
84 | 			prefix = kinds[kind].prefix,
85 | 			style = style,
86 | 			label = custom_label,
87 | 			counter = 'none'
88 | 	})
89 | 
90 | 	-- set this statement's kind to the new kind
91 | 	self.kind = new_kind
92 | 
93 | end
94 | 


--------------------------------------------------------------------------------
/src/Statement.new_kind_unnumbered.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:new_kind_unnumbered create a new unnumbered kind
 2 | -- if needed, based on a statement's kind
 3 | -- Uses and updates:
 4 | --		self.kind, this statement's current kind
 5 | --		self.setup.kinds the kinds table
 6 | --		self.setup.styles the styles table
 7 | function Statement:new_kind_unnumbered()
 8 | 	local kinds = self.setup.kinds -- pointer to the kinds table
 9 | 	local styles = self.setup.styles -- pointer to the styles table	
10 | 	local kind = self.kind
11 | 	local kind_key, style_key
12 | 
13 | 	-- do nothing if this statement's kind is already unumbered
14 | 	if kinds[kind] and kinds[kind].counter
15 | 			and kinds[kind].counter == 'none' then
16 | 		return
17 | 	end
18 | 
19 | 	-- if there's already a `-unnumbered` variant for this kind
20 | 	-- switch the kind to this
21 | 	kind_key = kind..'-unnumbered'
22 | 	if kinds[kind_key] and kinds[kind_key].counter
23 | 			and kinds[kind_key].counter == 'none' then
24 | 		self.kind = kind_key
25 | 		return
26 | 	end
27 | 
28 | 	-- otherwise create a new unnumbered variant
29 | 	kind_key = kind..'-unnumbered'
30 | 	style_key = kinds[kind].style -- use the original style
31 | 
32 | 	-- ensure the kind key is new
33 | 	local n = 0
34 | 	while kinds[kind_key] do
35 | 		n = n + 1
36 | 		kind_key = kind..'-unnumbered-'..tostring(n)
37 | 	end
38 | 
39 | 	-- create the new kind
40 | 	-- keep the original prefix and label; set its counter to 'none'
41 | 	self.setup.kinds[kind_key] = {}
42 | 	self.setup.kinds[kind_key].prefix = kinds[kind].prefix
43 | 	self.setup.kinds[kind_key].style = style_key
44 | 	self.setup.kinds[kind_key].label = kinds[kind].label -- Inlines
45 | 	self.setup.kinds[kind_key].counter = 'none'
46 | 
47 | 	-- set this statement's kind to the new kind
48 | 	self.kind = kind_key
49 | 
50 | end


--------------------------------------------------------------------------------
/src/Statement.parse_DefList.lua:
--------------------------------------------------------------------------------
  1 | ---Statement:parse_DefList parse a DefinitionList element into a statement
  2 | -- Parses a DefinitionList element into a statement, setting its
  3 | -- kind, identifier, label, info, acronym, content. 
  4 | -- Turns its Plain blocks into Para, for uniformity with fenced Divs.
  5 | -- Assumes the element contains only one DefinitionList item.
  6 | -- Creates new kinds and styles as needed.
  7 | -- Updates:
  8 | --		self.content
  9 | --		self.identifier
 10 | -- 		self.label
 11 | --		self.custom_label
 12 | --		self.kind
 13 | --		self.acronym
 14 | --		self.crossref_label
 15 | -- 		
 16 | --@param elem pandoc DefinitionList element (optional) element to be parsed
 17 | --											defaults to self.element
 18 | --@return bool true if successful, false if not
 19 | function Statement:parse_DefList(elem)
 20 | 	local setup = self.setup -- points to the setup table
 21 | 	local options = setup.options -- points to the options table
 22 | 	local kinds = setup.kinds -- points to the kinds table
 23 | 	local aliases = setup.aliases -- points to the aliases table
 24 | 	elem = elem or self.element
 25 | 	local item -- the first DefinitionList item
 26 | 	local expression, definitions -- the item's expression and definitions
 27 | 	local identifier -- string, user-provided identifier if found
 28 | 
 29 | 	-- safety check
 30 | 	if not elem.t or elem.t ~= 'DefinitionList' then
 31 | 		message('ERROR', 	'Non-DefinitionList element passed to the parse_DefList function,'
 32 | 											..' this should not have happened.')
 33 | 		return
 34 | 	end
 35 | 
 36 | 	-- ignore empty DefinitionList
 37 | 	if not elem.content[1] then
 38 | 		return
 39 | 	end
 40 | 
 41 | 	self.kind, item = self:parse_DefList_kind(elem.content[1])
 42 | 
 43 | 	-- return if failed to match
 44 | 	if not self.kind then
 45 | 		message('ERROR', 	'DefinitionList element passed to the parse DefinitionList function,'
 46 | 											..' without DefListitem_is_statement check,'
 47 | 											..'this should not have happened.')
 48 | 		return 
 49 | 	end
 50 | 
 51 | 	-- item[1]: expression defined
 52 | 	-- item[2]: list of Blocks, definitions
 53 | 	expression = item[1]
 54 | 	definitions = item[2]
 55 | 
 56 | 	-- Turn top-level Plain in definitions into Para
 57 | 	for _,definition in ipairs(definitions) do
 58 | 		for i = 1, #definition do
 59 | 			if definition[i].t and definition[i].t == 'Plain' then
 60 | 				definition[i] = pandoc.Para(definition[i].content)
 61 | 			end
 62 | 		end
 63 | 	end
 64 | 
 65 | 	-- Process expression: extract any label, info, acronym
 66 | 	-- extract id,
 67 | 	-- insert the remainder in the first paragraph of 
 68 | 	-- the definition.
 69 | 
 70 | 	-- extract any label, info, acronym from expression
 71 | 	local result = self:parse_heading_inlines(expression)
 72 | 	if result then
 73 | 		self.acronym = result.acronym
 74 | 		self.custom_label = result.custom_label
 75 | 		self.info = result.info
 76 | 		expression = result.remainder
 77 | 	end
 78 | 
 79 | 	-- look for an id in the expression
 80 | 	local identifier, new_expression = self:parse_identifier(expression)
 81 | 	if identifier then
 82 | 		self.identifier = identifier
 83 | 		expression = new_expression
 84 | 	end
 85 | 
 86 | 	-- clean up
 87 | 	expression = Statement:trim_dot_space(expression)
 88 | 	expression = Statement:trim_dot_space(expression, 'reverse')
 89 | 
 90 | 	-- if any remainder, insert in the first Para of the first definition
 91 | 	-- or create a new Para if necessary
 92 | 	if expression and #expression > 0 then
 93 | 		definitions[1] = definitions[1] or pandoc.List:new()
 94 | 		if definitions[1][1] and definitions[1][1].t == 'Para' then
 95 | 			definitions[1][1].content = expression:extend(
 96 | 																		definitions[1][1].content)
 97 | 		else 
 98 | 			definitions[1]:insert(1, pandoc.Para(expression))
 99 | 		end
100 | 	end
101 | 
102 | 	-- concatenate definitions as the statement's content
103 | 	self.content = pandoc.List:new() -- Blocks
104 | 	for _,definition in ipairs(definitions) do
105 | 		if #definition > 0 then
106 | 			self.content:extend(definition)
107 | 		end
108 | 	end
109 | 
110 | 	return true
111 | 
112 | end


--------------------------------------------------------------------------------
/src/Statement.parse_DefList_kind.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:parse_DefList_kind: extracts the kind from a DefList, if any
 2 | -- A DefinitionList item is a statement if its defined expression starts
 3 | -- with a Str element whose text matches a statement kind (or alias).
 4 | --@param item item of DefinitionList element
 5 | --@return string or nil element's kind (key of `setup.kinds`) or nil
 6 | --@return item the modified DefinitionList item
 7 | function Statement:parse_DefList_kind(item)
 8 | 	setup = setup or self.setup -- pointer to the setup table
 9 | 	local kinds = setup.kinds -- pointer to the kinds table
10 | 	item = item or self.element 
11 | 					and self.element.t == 'DefinitionList' 
12 | 					and self.element.content[1]
13 | 	local expression -- Inlines expression defined, i.e. item[1]
14 | 	local kind -- kind key, if found
15 | 	--local new_item -- modified item
16 | 
17 | 	if item then
18 | 
19 | 		expression = item[1]
20 | 		if expression[1].t and expression[1].t == 'Str' then
21 | 
22 | 			-- check that it does match a kind
23 | 			-- ignore any dot at the end of the string
24 | 			local str = expression[1].text:match('(.+)%.$') or expression[1].text
25 | 			kind = self:is_kind_key(str, setup)
26 | 
27 | 			-- if found, extract it
28 | 			-- warning, side-effect: this modifies the document's own blocks.
29 | 		  if kind then
30 | 
31 | 		  	expression = item[1]
32 | 		  	-- remove the 'Str' that matched
33 | 		  	expression:remove(1)
34 | 		  	-- remove any leading space dot left
35 | 		  	expression = self:trim_dot_space(expression, 'forward')
36 | 		  	-- store
37 | 		  	item[1] = expression
38 | 		  	-- return positive result
39 | 		  	return kind, item
40 | 
41 | 		  end
42 | 
43 | 		end
44 | 
45 | 	end
46 | 
47 | end
48 | 


--------------------------------------------------------------------------------
/src/Statement.parse_Div.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:parse_Div parse a Div element into a statement
 2 | -- Parses a pandoc Div element into a statement, setting its
 3 | -- kind, identifier, label, info, acronym, content. 
 4 | -- Creates new kinds and styles as needed.
 5 | -- Updates:
 6 | --		self.content
 7 | --		self.identifier
 8 | -- 		self.label
 9 | --		self.custom_label
10 | --		self.kind
11 | --		self.acronym
12 | --		self.crossref_label
13 | -- 		
14 | --@param elem pandoc Div element (optional) element to be parsed
15 | --											defaults to self.element
16 | --@return bool true if successful, false if not
17 | function Statement:parse_Div(elem)
18 | 	local setup = self.setup -- points to the setup table
19 | 	local options = setup.options -- points to the options table
20 | 	local kinds = setup.kinds -- points to the kinds table
21 | 	local aliases = setup.aliases -- points to the aliases table
22 | 	elem = elem or self.element
23 | 
24 | 	-- safety check
25 | 	if not elem.t or elem.t ~= 'Div' then
26 | 		message('ERROR', 	'Non-Div element passed to the parse Div function,'
27 | 											..' this should not have happened.')
28 | 		return
29 | 	end
30 | 
31 | 	-- find the element's base kind
32 | 	--	Div_is_statement() returns the kinds matched by self.element
33 | 	local kinds_matched = self:Div_is_statement()
34 | 	if not kinds_matched then 
35 | 		message('ERROR', 	'Div element passed to the parse Div function,'
36 | 											..' without Div_is_statement check,'
37 | 											..'this should not have happened.')
38 | 		return 
39 | 	end
40 | 	-- warn if there's still more than one kind
41 | 	if #kinds_matched > 1 then
42 | 		local str = ''
43 | 		for _,match in ipairs(kinds_matched) do
44 | 			str = str .. ' ' .. match
45 | 		end
46 | 		message('WARNING', 'A Div matched several statement kinds: '
47 | 			.. str .. '. Treated as kind '.. kinds_matched[1] ..'.')
48 | 	end
49 | 	self.kind = kinds_matched[1]
50 | 
51 | 	-- remove the kinds matched from the Div's attributes
52 | 	for _,kind in ipairs(kinds_matched) do
53 | 		local _,position = self.element.classes:find(kind)
54 | 		self.element.classes:remove(position)
55 | 	end
56 | 
57 | 	-- get the Div's user-specified id, if any
58 | 	if elem.identifier and elem.identifier ~= '' then
59 | 		self.identifier = elem.identifier
60 | 	end
61 | 
62 | 	-- extract any label, acronym, info
63 | 	-- these are in the first paragraph, if any
64 | 	-- NOTE: side-effect, the original tree's element is modified
65 | 	if elem.content[1] and elem.content[1].t == 'Para' then
66 | 		local result = self:parse_heading_inlines(elem.content[1].content)
67 | 		if result then
68 | 			self.acronym = result.acronym
69 | 			self.custom_label = result.custom_label
70 | 			self.info = result.info
71 | 			-- if any remainder, place in the Para otherwise remove
72 | 			if result.remainder and #result.remainder > 0 then
73 | 				elem.content[1].content = result.remainder
74 | 			else
75 | 				elem.content:remove(1)
76 | 			end
77 | 		end
78 | 	end
79 | 
80 | 	-- store the content
81 | 	self.content = elem.content
82 | 
83 | 	return true
84 | 
85 | end


--------------------------------------------------------------------------------
/src/Statement.parse_heading_inlines.lua:
--------------------------------------------------------------------------------
  1 | --- Statement:parse_heading_inlines: parse statement heading inlines
  2 | -- into custom label, acronym, info if present, and extract
  3 | -- them from those inlines. Return them in a table.
  4 | -- @TODO: handle acronym-only statements
  5 | -- Expected format, where [...] means optional:
  6 | --		[**[[Acronym] Custom Label] [Info1].**] [Info2[.]] Content
  7 | --		[**[[Acronym] Custom Label] [Info1]**.] [Info2[.]] Content
  8 | -- Where:
  9 | --		- Acronym is Inlines delimited by matching parentheses, e.g. (NPE)
 10 | --		- Info1, Info2 are either Inlines delimited by matching 
 11 | --			parentheses, or a Cite element,
 12 | --		- only one of Info1 or Info2 is present. The latter is treated
 13 | --			as part of the content otherwise.
 14 | --		- single spaces before the heading or surrounding the dot
 15 | --			are tolerated.
 16 | --		- a single bracketed content is assumed to be acronym rather than info.
 17 | -- Updates:
 18 | --		self.custom_label Inlines or nil, content of the label if found
 19 | --		self.acronym Inlines or nil, acronym
 20 | --		self.content Blocks, remainder of the statement after extraction
 21 | --@return table { acronym = Inlines or nil,
 22 | --								custom_label = Inlines or nil,
 23 | --								info = Inlines or nil
 24 | --								remainder = Inlines
 25 | --								}
 26 | --				or nil if no modification made
 27 | function Statement:parse_heading_inlines(inlines)
 28 | 	local acro_delimiters = self.setup.options.acronym_delimiters 
 29 | 											or {'(',')'} -- acronym delimiters
 30 | 	local info_delimiters = self.setup.options.info_delimiters 
 31 | 											or {'(',')'} -- info delimiters
 32 | 	local custom_label, acronym, info
 33 | 
 34 | 	--- parse_Strong: try to parse a Strong element into acronym,
 35 | 	-- label and info.
 36 | 	-- @param elem pandoc Strong element
 37 | 	-- @return info, Inlines or Cite information if found
 38 | 	-- @return cust_lab, Inlines custom label if found
 39 | 	-- @return acronym, Inlines, acronym if found
 40 | 	function parse_Strong(elem)
 41 | 		-- must clone to avoid changing the original element 
 42 | 		-- in case parsing fails
 43 | 		local result = elem.content:clone()
 44 | 		local info, cust_lab, acro
 45 | 
 46 | 		-- remove trailing space / dot
 47 | 		result = self:trim_dot_space(result, 'reverse')
 48 | 
 49 | 		-- Acronym is first content between balanced brackets
 50 | 		-- encountered in forward order
 51 | 		if #result > 0 then
 52 | 			acro, result = self:extract_fbb(result, 'forward', acro_delimiters)
 53 | 			self:trim_dot_space(result, 'forward')
 54 | 		end
 55 | 
 56 | 		-- Info is first Cite or content between balanced brackets 
 57 | 		-- encountered in reverse order.
 58 | 		if result[#result].t == 'Cite' then
 59 | 			info = pandoc.Inlines(result[#result])
 60 | 			result:remove(#result)
 61 | 			result = self:trim_dot_space(result, 'reverse')
 62 | 		else
 63 | 			info, result = self:extract_fbb(result, 'reverse', info_delimiters)
 64 | 			result = self:trim_dot_space(result, 'reverse')
 65 | 		end
 66 | 			
 67 | 		-- Custom label is whatever remains
 68 | 		if #result > 0 then
 69 | 			cust_lab = result
 70 | 		end
 71 | 
 72 | 		-- If we have acro but not cust_label that's a failure
 73 | 		if acro and not cust_lab then
 74 | 			return nil, nil, nil
 75 | 		else
 76 | 			return info, cust_lab, acro
 77 | 		end
 78 | 	end
 79 | 
 80 | 	-- FUNCTION BODY
 81 | 
 82 | 	-- prevent modification of the source document by cloning
 83 | 	if inlines and type(inlines) == 'Inlines' and #inlines > 0 then
 84 | 		inlines = inlines:clone()
 85 | 	else
 86 | 		return
 87 | 	end
 88 | 
 89 | 	-- inlines start with Strong?
 90 | 	-- if yes, try to parse and remove if successful
 91 | 	if inlines[1].t == 'Strong' then
 92 | 		info, custom_label, acronym = parse_Strong(inlines[1])
 93 | 		if custom_label or info then
 94 | 			inlines:remove(1)
 95 | 			inlines = self:trim_dot_space(inlines, 'forward')
 96 | 		end
 97 | 	end
 98 | 
 99 | 	-- if we don't have info yet, try to find it at the beginning
100 | 	-- of (what remains of) the Para's content.
101 | 	if not info then
102 | 		if inlines[1] and inlines[1].t == 'Cite' then
103 | 			info = pandoc.Inlines(inlines[1])
104 | 			inlines:remove(1)
105 | 			inlines = self:trim_dot_space(inlines, 'forward')
106 | 		else
107 | 			info, inlines = self:extract_fbb(inlines, 
108 | 																	'forward', info_delimiters)
109 | 			inlines = self:trim_dot_space(inlines, 'forward')
110 | 		end
111 | 
112 | 	end
113 | 
114 | 	-- return a table if we found anything
115 | 	if custom_label or info then
116 | 		return {
117 | 			acronym = acronym,
118 | 			custom_label = custom_label,
119 | 			info = info,
120 | 			remainder = #inlines>0 and inlines
121 | 									or nil
122 | 		}
123 | 	end
124 | 
125 | end
126 | 


--------------------------------------------------------------------------------
/src/Statement.parse_identifier.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:parse_indentifier find and extract a \label{...}
 2 | -- or {#...} identifier from Inlines
 3 | function Statement:parse_identifier(inlines)
 4 | 	local id -- string, identifier
 5 | 	local result
 6 | 
 7 | 	--pick_id: a filter to pick ids in RawInlines or Str
 8 | 	local pick_id = {
 9 | 		RawInline = function(elem)
10 | 			id = elem.text:match('^\\label{(%g+)}$')
11 | 			if id then return {} end
12 | 		end,
13 | 		Str = function(elem)
14 | 			id = elem.text:match('^{#(%g+)}$')
15 | 			if id then return {} end
16 | 		end,
17 | 	}
18 | 
19 | 	if inlines and type(inlines) == 'Inlines' and #inlines > 0 then
20 | 
21 | 		-- prevent modification of the source document by cloning
22 | 		-- and apply the filter
23 | 		result = inlines:clone():walk(pick_id)
24 | 		-- if something found, return the identifier and modified inlines
25 | 		if id then
26 | 			return id, result
27 | 		end
28 | 
29 | 	end
30 | end


--------------------------------------------------------------------------------
/src/Statement.set_count.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:set_count: increment a statement kind's counter
 2 | -- Increments the kind's count of this statement kind or
 3 | -- its shared counter's kind.
 4 | -- Note: set_is_numbered ensures that the kind's counter
 5 | -- is a counting one.
 6 | --@return nil
 7 | function Statement:set_count()
 8 | 	local kinds = self.setup.kinds -- pointer to the kinds table
 9 | 	local counter = kinds[self.kind].counter
10 | 	-- kind to count: shared counter's kind or self.kind
11 | 	local kind_to_count = kinds[counter] and counter
12 | 												or self.kind
13 | 
14 | 	kinds[kind_to_count].count =	kinds[kind_to_count].count
15 | 																and kinds[kind_to_count].count + 1
16 | 																or 1
17 | end


--------------------------------------------------------------------------------
/src/Statement.set_identifier.lua:
--------------------------------------------------------------------------------
 1 | --- Statement:set_identifier: set a statement's id
 2 | -- and register it with the crossref manager.
 3 | -- Updates:
 4 | --		self.identifier
 5 | --		self.elem.attr.identifier
 6 | --@return nil
 7 | function Statement:set_identifier()
 8 | 	local elem = self.element
 9 | 	local crossref = self.setup.crossref -- points to the crossref manager
10 | 	local style = self.setup.kinds[self.kind].style
11 | 	local crossref_font = self.setup.styles[style].crossref_font
12 | 
13 | 	---register: register id using a given mode
14 | 	-- store its kind, crossref_label, crossref_font
15 | 	-- store the new id in self.identifier and elem.attr.identifier 
16 | 	--@param id string the identifier to be registered
17 | 	--@param attr map, any attributes that were set by parsing the id
18 | 	--@param mode string mode to be used, 'new', 'redirect', 'strict'
19 | 	--@return id, the id generated
20 | 	function register(id, attr, mode)
21 | 		attr = attr or {}
22 | 		local final_id
23 | 
24 | 		-- add attributes
25 | 		attr.type = 'Statement'
26 | 		attr.label = self.crossref_label
27 | 		attr.kind = self.kind
28 | 		attr.crossref_font = crossref_font
29 | 
30 | 		-- register
31 | 		final_id = crossref:register_identifier(id, attr, mode)
32 | 
33 | 		-- udpate the statement's `self.identifier` field
34 | 		self.identifier = final_id
35 | 		-- update the element's identifier 
36 | 		-- (in case writers return it to the document)
37 | 		if elem.attr then
38 | 			elem.attr.identifier = final_id
39 | 		end
40 | 
41 | 		return final_id
42 | 	end
43 | 
44 | 	-- MAIN FUNCTION BODY
45 | 	
46 | 	--		user-specified id?
47 | 	if self.identifier then
48 | 		local id, attr = crossref:parse_identifier(self.identifier)
49 | 		local final_id = register(id, attr, 'redirect')
50 | 		if final_id ~= id then
51 | 			message('WARNING', 	'The ID `'..id..'` you gave to a `'..self.kind..'` statement'
52 | 													..' turns out to be a duplicate. Either you used it twice,'
53 | 													..' or it matches an automatically-generated section ID,'
54 | 													..' or you tried to refer to the statement with '
55 | 													..' an empty Span `[]{#'..id..'}` rather than a Link' 
56 | 													..' `[](#'..id..') somewhere.'
57 | 													.." I've changed the ID to `"..final_id..' and made '
58 | 													..' all crossreferences to `'..id..'` point to it'
59 | 													..' instead. Some crossreferences may not be correct,'
60 | 													..' you should give this statement another ID.')
61 | 	end
62 | 
63 | 	-- 		acronym?
64 | 	elseif self.acronym then
65 | 		local id = stringify(self.acronym):gsub('[^%w]','-')
66 | 		local final_id = register(id, {}, 'new')
67 | 		if final_id ~= id then
68 | 			message('WARNING', 'The acronym `'..id..'` you gave to a `'..self.kind..'` statement'
69 | 													..' could not be used as its ID because that ID already existed.'
70 | 													.." If you're not planning to crossrefer to this statement, "
71 | 													.." that's not a problem. But if you are the crossreferences "
72 | 													.." won't work as intended."
73 | 													.." Make sure you didn't try to refer to this statement with "
74 | 													..' an empty Span `[]{#'..id..'}` rather than a Link' 
75 | 													..' `[](#'..id..') somewhere, and otherwise give it a custom ID.'
76 | 													.." In the meanwhile I've given it ID "..final_id.." instead."
77 | 				)
78 | 		end
79 | 
80 | 	--	custom label?
81 | 	elseif self.custom_label then
82 | 		local id = stringify(self.custom_label):lower():gsub('[^%w]','-')
83 | 		local final_id = register(id, {}, 'new')
84 | 		if final_id ~= id then
85 | 			message('WARNING', 'The custom label `'..id..'` you gave to a `'..self.kind..'` statement'
86 | 													..' could not be used as its ID because that ID already existed.'
87 | 													.." If you're not planning to crossrefer to this statement, "
88 | 													.." that's not a problem. But if you are the crossreferences "
89 | 													.." won't work as intended."
90 | 													.." Make sure you didn't try to refer to this statement with "
91 | 													..' an empty Span `[]{#'..id..'}` rather than a Link' 
92 | 													..' `[](#'..id..') somewhere, and otherwise give it a custom ID.'
93 | 													.." In the meanwhile I've given it ID "..final_id.." instead."
94 | 				)
95 | 		end
96 | 
97 | 	end
98 | 
99 | end


--------------------------------------------------------------------------------
/src/Statement.set_is_numbered.lua:
--------------------------------------------------------------------------------
 1 | --- Statement:set_is_numbered: determine whether a statement is numbered
 2 | -- Checks if the element has a 'unnumbered' attribute or 'none' counter.
 3 | -- Updates:
 4 | --	self.is_numbered Bool whether the statement is numbered
 5 | --@param elem the statement element Div or item in Definition list
 6 | --@return nil
 7 | function Statement:set_is_numbered(elem)
 8 | 	kinds = self.setup.kinds -- pointer to the kinds table
 9 | 	elem = elem or self.element
10 | 
11 | 	-- is_counter: whether a counter is a level, LaTeX level or 'self'
12 | 	local function is_counter(counter) 
13 | 		return counter == 'self'
14 | 					or (type(counter) == 'number' and counter >= 1 and counter <= 6)
15 | 					or self.setup:get_level_by_LaTeX_name(counter)
16 | 		end
17 | 
18 | 	-- custom label theorems aren't numbered
19 | 	if self.custom_label then
20 | 
21 | 			self.is_numbered = false
22 | 
23 | 	elseif elem.t == 'Div' and elem.classes:includes('unnumbered') then
24 | 
25 | 			self.is_numbered = false
26 | 
27 | 	elseif kinds[self.kind] and kinds[self.kind].counter then
28 | 		-- check if this is a counting counter
29 | 		local counter = kinds[self.kind].counter
30 | 		-- if shared counter, switch to that counter
31 | 		if kinds[counter] then
32 | 			counter = kinds[counter].counter
33 | 		end
34 | 		-- check this is a counting counter
35 | 		if is_counter(counter) then
36 | 			self.is_numbered = true
37 | 		else
38 | 			self.is_numbered = false
39 | 		end
40 | 
41 | 	else -- 'none' or something unintelligible
42 | 
43 | 		self.is_numbered = false
44 | 		
45 | 	end
46 | end
47 | 
48 | 


--------------------------------------------------------------------------------
/src/Statement.set_labels.lua:
--------------------------------------------------------------------------------
 1 | --- Statement:set_labels: Set a statement's label and 
 2 | -- crossref label. The label is used in the statement
 3 | -- heading, the crossref label in references. 
 4 | -- Ex: label "Theorem 1.1", crossref_label "1.1"
 5 | -- Updates:
 6 | --		self.label
 7 | --		self.crossref_label
 8 | -- Crossref label priority:
 9 | --		- use self.crossref_label, if user set
10 | -- 		- use self.acronym, otherwise
11 | --		- use self.label (custom label), otherwise
12 | --		- use formatted statement count
13 | --		- '??'
14 | --@return nil
15 | function Statement:set_labels()
16 | 	local kinds = self.setup.kinds -- pointer to the kinds table
17 | 	local kind = self.kind -- the statement's kind
18 | 	local delimiter = self.setup.options.counter_delimiter
19 | 										or '.' -- separates section counter and statement counter
20 | 	local counters = self.setup.counters -- pointer to the counters table
21 | 	local number -- string formatted number, if numbered statement
22 | 
23 | 	-- If numbered, create the `number` string
24 | 	if self.is_numbered then
25 | 		-- counter; if shared, use the source's counter
26 | 		local counter = kinds[kind].counter
27 | 		local kind_to_count = kind
28 | 		if kinds[counter] then
29 | 			kind_to_count = counter
30 | 			counter = kinds[counter].counter
31 | 		end
32 | 		-- format depending on counter == `self`, <level> or 'none'/unintelligible
33 | 		local level = self.setup:get_level_by_LaTeX_name(counter)
34 | 		local count = kinds[kind_to_count].count or 0
35 | 		if level then
36 | 			number = self.setup:write_counter(level)..delimiter..count
37 | 		elseif counter == 'self' then
38 | 			number = tostring(count)
39 | 		else
40 | 			number = '??'
41 | 		end
42 | 	end
43 | 
44 | 	-- Label
45 | 	if self.custom_label then
46 | 		self.label = self.custom_label
47 | 	elseif kinds[kind].label then
48 | 		self.label = kinds[kind].label:clone()
49 | 		if number then
50 | 			self.label:extend({pandoc.Space(), pandoc.Str(number)})
51 | 		end
52 | 	end
53 | 
54 | 	-- Crossref Label
55 | 	-- (future use) use self.crossref_label if set (open this to Div attributes?)
56 | 	if self.crossref_label then
57 | 	-- or use acronym
58 | 	elseif self.acronym then
59 | 		self.crossref_label = self.acronym
60 | 	-- or custom label
61 | 	elseif self.custom_label then
62 | 		self.crossref_label = self.custom_label
63 | 	-- or formatted statement count
64 | 	elseif number then
65 | 		self.crossref_label = pandoc.Inlines(pandoc.Str(number))
66 | 	-- or set it to '??'
67 | 	else
68 | 		self.crossref_label = pandoc.Inlines(pandoc.Str('??'))
69 | 	end
70 | 
71 | end
72 | 


--------------------------------------------------------------------------------
/src/Statement.set_values.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:set_fields: set a statement's fields based on parsed values
 2 | -- This function is called after parsing a Div or DefinitionList
 3 | -- Uses:
 4 | --		self.kind
 5 | -- 		self.identifier
 6 | --		self.custom_label
 7 | --		self.acronym
 8 | --		self.info
 9 | --		self.content
10 | -- Updates and sets:
11 | --		self.kind   (may create a new kind from custom label)
12 | --		self.identifier 	(assigns automatic IDs)
13 | --		self.is_numbered  (whether the statement is numbered)
14 | --		self.kinds[self.kind].count the statement's count
15 | -- 		self.label
16 | --		self.custom_label
17 | --		self.crossref_label
18 | --@param elem pandoc Div element (optional) element to be parsed
19 | --											defaults to self.element
20 | --@return bool true if successful, false if not
21 | function Statement:set_values()
22 | 
23 | 	-- if custom label, create a new kind
24 | 	if self.custom_label then
25 | 		self:new_kind_from_label()
26 | 	end
27 | 
28 | 	-- if unnumbered, we may need to create a new kind
29 | 	-- if numbered, increase the statement's count
30 | 	self:set_is_numbered() -- set self.is_numbered
31 | 	if not self.is_numbered then
32 | 		self:new_kind_unnumbered()
33 | 	else
34 | 		self:set_count() -- update the kind's counter
35 | 	end
36 | 
37 | 	-- set label and crossref labels
38 | 	self:set_labels()
39 | 
40 | 	-- set identifier
41 | 	self:set_identifier()
42 | 
43 | end


--------------------------------------------------------------------------------
/src/Statement.trim_dot_space.lua:
--------------------------------------------------------------------------------
 1 | ---Statement:trim_dot_space: remove leading/trailing dot space in Inlines.
 2 | --@param inlines pandoc Inlines
 3 | --@param direction 'reverse' for trailing, otherwise leading
 4 | --@return result pandoc Inlines
 5 | function Statement:trim_dot_space(inlines, direction)
 6 | 	local reverse = false
 7 | 	if direction == 'reverse' then reverse = true end
 8 | 	
 9 | 	-- function to return first position in the desired direction
10 | 	function firstpos(list)
11 | 		return reverse and #list or 1
12 | 	end
13 | 
14 | 	-- safety check
15 | 	if not inlines or #inlines == 0 then return inlines end
16 | 
17 | 	-- remove sequences of spaces and dots
18 | 	local keep_looking = true
19 | 	while keep_looking do
20 | 		keep_looking = false
21 | 		if #inlines > 0 then
22 | 			if inlines[firstpos(inlines)].t == 'Space' then
23 | 				inlines:remove(firstpos(inlines))
24 | 				keep_looking = true
25 | 			elseif inlines[firstpos(inlines)].t == 'Str' then
26 | 				-- trim trailing dots and spaces from string text
27 | 				local str = inlines[firstpos(inlines)].text:match('(.*)[%.%s]+$')
28 | 				if str then
29 | 					if str == '' then
30 | 						inlines:remove(firstpos(inlines))
31 | 					else
32 | 						inlines[firstpos(inlines)].text = str
33 | 					end
34 | 					keep_looking = true
35 | 				end
36 | 			end
37 | 		end
38 | 	end
39 | 
40 | 	return inlines
41 | end
42 | 


--------------------------------------------------------------------------------
/src/Statement.write.lua:
--------------------------------------------------------------------------------
 1 | --- Statement:write: format the statement as an output string.
 2 | -- @param format string (optional) format desired if other than FORMAT
 3 | -- @return Blocks blocks to be inserted. 
 4 | function Statement:write(format)
 5 | 	local format = format or FORMAT
 6 | 	local blocks = pandoc.List:new()
 7 | 
 8 | 	-- do we have before_first includes to include before any
 9 | 	-- definition? if yes include them here and wipe it out
10 | 	if self.setup.includes.before_first then
11 | 		blocks:extend(self.setup.includes.before_first)
12 | 		self.setup.includes.before_first = nil
13 | 	end
14 | 
15 | 	-- do we need to write the kind definition first?
16 | 	-- if local blocks are returned, insert them
17 | 	local write_kind_local_blocks = self:write_kind()
18 | 	if write_kind_local_blocks then
19 | 		blocks:extend(write_kind_local_blocks)
20 | 	end
21 | 
22 | 	-- format the statement
23 | 
24 | 	if format:match('latex') then
25 | 
26 | 		blocks:extend(self:write_latex())
27 | 
28 | 	elseif format:match('html') then
29 | 
30 | 		blocks:extend(self:write_html())
31 | 
32 | 	elseif format:match('jats') then
33 | 
34 | 		blocks:extend(self:write_jats())
35 | 
36 | 	else
37 | 
38 | 		blocks:extend(self:write_native())
39 | 
40 | 	end
41 | 	
42 | 	return blocks
43 | 
44 | end


--------------------------------------------------------------------------------
/src/Statement.write_html.lua:
--------------------------------------------------------------------------------
 1 | ---Statement.write_latex: write a statement in html
 2 | --@return Blocks
 3 | -- HTML formatting
 4 | -- we create a Div
 5 | --	<div class='statement <kind> <style>'>
 6 | -- 	<p class='statement-first-paragraph'>
 7 | --		<span class='statement-head'>
 8 | --			<span class='statement-label'> label inlines </span>
 9 | --		  <span class='statement-info'>( info inlines )</span>
10 | --			<span class='statement-spah'> </span>
11 | --		first paragraph content, if any
12 | --	</p>
13 | --  content blocks
14 | -- </div>
15 | function Statement:write_html()
16 | 	local styles = self.setup.styles -- pointer to the styles table
17 | 	local style = self.setup.kinds[self.kind].style -- this statement's style
18 | 	local label_inlines, label_span, info_span 
19 | 	local heading_inlines, heading_span
20 | 	local attributes
21 | 	local blocks = pandoc.List:new()
22 | 
23 | 	-- create label span; could be custom-label or kind label
24 | 	label_inlines = self:write_label() 
25 | 	if #label_inlines > 0 then
26 | 		label_span = pandoc.Span(label_inlines, 
27 | 											{class = 'statement-label'})
28 | 	end
29 | 	-- create info span
30 | 	if self.info then 
31 | 		self.info:insert(1, pandoc.Str('('))
32 | 		self.info:insert(pandoc.Str(')'))
33 | 		info_span = pandoc.Span(self.info, 
34 | 										{class = 'statement-info'})
35 | 	end
36 | 	-- put heading together
37 | 	if label_span or info_span then
38 | 		heading_inlines = pandoc.List:new()
39 | 		if label_span then
40 | 			heading_inlines:insert(label_span)
41 | 		end
42 | 		if label_span and info_span then
43 | 			heading_inlines:insert(pandoc.Space())
44 | 		end
45 | 		if info_span then
46 | 			heading_inlines:insert(info_span)
47 | 		end
48 | 		-- insert punctuation defined in style
49 | 		if styles[style].punctuation then
50 | 			heading_inlines:insert(pandoc.Str(
51 | 				styles[style].punctuation
52 | 				))
53 | 		end
54 | 		heading_span = pandoc.Span(heading_inlines,
55 | 									{class = 'statement-heading'})
56 | 	end
57 | 
58 | 	-- if heading, insert it in the first paragraph if any
59 | 	-- otherwise make it its own paragraph
60 | 	if heading_span then
61 | 		if self.content[1] and self.content[1].t 
62 | 				and self.content[1].t == 'Para' then
63 | 			self.content[1].content:insert(1, heading_span)
64 | 			-- add space after heading
65 | 			self.content[1].content:insert(2, pandoc.Span(
66 | 										{pandoc.Space()}, {class='statement-spah'}
67 | 				))
68 | 		else
69 | 			self.content:insert(1, pandoc.Para({heading_span}))
70 | 		end
71 | 	end
72 | 
73 | 	-- prepare Div attributes
74 | 	-- keep the original element's attributes if any
75 | 	attributes = self.element.attr or pandoc.Attr()
76 | 	if self.identifier then
77 | 			attributes.identifier = self.identifier
78 | 	end
79 | 	-- add the `statement`, kind, style and unnumbered classes
80 | 	-- same name for kind and style shouldn't be a problem
81 | 	attributes.classes:insert('statement')
82 | 	attributes.classes:insert(self.kind)
83 | 	attributes.classes:insert(style)
84 | 	if not self.is_numbered 
85 | 			and not attributes.classes:includes('unnumbered') then
86 | 		attributes.classes:insert('unnumbered')
87 | 	end
88 | 
89 | 	-- create the statement Div and insert it
90 | 	blocks:insert(pandoc.Div(self.content, attributes))
91 | 
92 | 	return blocks
93 | 
94 | end
95 | 


--------------------------------------------------------------------------------
/src/Statement.write_jats.lua:
--------------------------------------------------------------------------------
 1 | ---Statement.write_latex: write a statement in LaTeX
 2 | -- Pandoc's JATS writer turns Plain blocks in to <p>...</p>
 3 | -- for this reason we must write <label> and <title> inlines
 4 | -- to text before we insert them.
 5 | -- <statement>
 6 | --		<label> Kind label number or Custom label </label>
 7 | --		<title> info </title>
 8 | --		content blocks
 9 | -- </statement
10 | --@return Blocks
11 | function Statement:write_jats()
12 | 	doc_meta = self.setup.meta -- pointer to the doc's Meta
13 | 														 -- needed by pandoc.write
14 | 	local blocks = pandoc.List:new()
15 | 
16 | 	--write_to_jats: use pandoc to convert inlines to jats output
17 | 	--passing writer options that affect inlines formatting in JATS
18 | 	--@BUG even with the doc's meta, citeproc doesn't convert citations
19 | 	function write_to_jats(inlines)
20 | 		local result, doc
21 | 		local options = pandoc.WriterOptions({
22 | 				cite_method = PANDOC_WRITER_OPTIONS.cite_method,
23 | 				columns = PANDOC_WRITER_OPTIONS.columns,
24 | 				email_obfuscation = PANDOC_WRITER_OPTIONS.email_obfuscation,
25 | 				extensions = PANDOC_WRITER_OPTIONS.extensions,
26 | 				highlight_style = PANDOC_WRITER_OPTIONS.highlight_style,
27 | 				identifier_prefix = PANDOC_WRITER_OPTIONS.identifier_prefix,
28 | 				listings = PANDOC_WRITER_OPTIONS.listings,
29 | 				prefer_ascii = PANDOC_WRITER_OPTIONS.prefer_ascii,
30 | 				reference_doc = PANDOC_WRITER_OPTIONS.reference_doc,
31 | 				reference_links = PANDOC_WRITER_OPTIONS.reference_links,
32 | 				reference_location = PANDOC_WRITER_OPTIONS.reference_location,
33 | 				tab_stop = PANDOC_WRITER_OPTIONS.tab_stop,
34 | 				wrap_text = PANDOC_WRITER_OPTIONS.wrap_text,
35 | 		})
36 | 		doc = pandoc.Pandoc(pandoc.Plain(inlines), doc_meta)
37 | 		result = pandoc.write(doc, 'jats', options)
38 | 		return result:match('^<p>(.*)</p>$') or result or ''
39 | 
40 | 	end
41 | 
42 | 	blocks:insert(pandoc.RawBlock('jats', '<statement>'))
43 | 
44 | 	label_inlines = self:write_label() 
45 | 	if #label_inlines > 0 then
46 | 		local label_str = '<label>'..write_to_jats(label_inlines) 
47 | 											..'</label>'
48 | 		blocks:insert(pandoc.RawBlock('jats',label_str))
49 | 	end
50 | 
51 | 	if self.info then
52 | 		local info_str = 	'<title>'..write_to_jats(self.info)
53 | 											..'</title>'
54 | 		blocks:insert(pandoc.RawBlock('jats',info_str))
55 | 	end
56 | 
57 | 	blocks:extend(self.content)
58 | 
59 | 	blocks:insert(pandoc.RawBlock('jats', '</statement>'))
60 | 
61 | 	return blocks
62 | 
63 | end
64 | 
65 | 


--------------------------------------------------------------------------------
/src/Statement.write_kind.lua:
--------------------------------------------------------------------------------
  1 | --- Statement:write_kind: write the statement's kind definition as output string.
  2 | -- If the statement's kind is not yet defined, create blocks to define it
  3 | -- in the desired output format. These blocks are added to
  4 | -- `self.setup.includes.header` or returned to be added locally, 
  5 | -- depending on the `setup.options.define_in_header` setting.
  6 | -- @param kind string (optional) kind to be formatted, if not kind
  7 | -- @param format string (optional) format desired if other than FORMAT
  8 | -- @return blocks or {}, blocks to be added locally if any
  9 | function Statement:write_kind(kind, format)
 10 | 	local format = format or FORMAT
 11 | 	local kind = kind or self.kind
 12 | 	local counter = self.setup.kinds[kind].counter or 'none'
 13 | 	local shared_counter, counter_within
 14 | 	local blocks = pandoc.List:new() -- blocks to be written
 15 | 
 16 | 	-- check if the kind is already written
 17 | 	if self.setup.kinds[kind].is_written then
 18 | 		return {}
 19 | 	else
 20 | 		self.setup.kinds[kind].is_written = true
 21 | 	end
 22 | 
 23 | 	-- identify counter_within and shared_counter
 24 | 	if counter ~= 'none' and counter ~= 'self' then
 25 | 		if self.setup.kinds[counter] then
 26 | 			shared_counter = counter
 27 | 		elseif self.setup:get_level_by_LaTeX_name(counter) then
 28 | 			counter_within = counter
 29 | 		elseif self.setup:get_LaTeX_name_by_level(counter) then
 30 | 			counter_within = self.setup:get_LaTeX_name_by_level(counter)
 31 | 		else -- unintelligible, default to 'self'
 32 | 			message('WARNING', 'unintelligible counter for kind'
 33 | 				..kind.. '. Defaulting to `self`.')
 34 | 			counter = 'self'
 35 | 		end
 36 | 	end
 37 | 	-- if shared counter, ensure its kind is defined before
 38 | 	if shared_counter then
 39 | 		blocks:extend(self:write_kind(shared_counter))
 40 | 	end
 41 | 
 42 | 	-- write the style definition if needed
 43 | 	blocks:extend(self:write_style(self.setup.kinds[kind].style))
 44 | 
 45 | 	-- format
 46 | 	if format:match('latex') then
 47 | 	
 48 | 		local label = self.setup.kinds[kind].label 
 49 | 						or pandoc.Inlines(pandoc.Str(''))
 50 | 
 51 | 		-- in LaTeX we need to add the acronym in the label's definition
 52 | 		if self.acronym then
 53 | 
 54 | 			local acro_inlines = pandoc.List:new()
 55 | 			acro_inlines:insert(pandoc.Str('('))
 56 | 			acro_inlines:extend(self.acronym)
 57 | 			acro_inlines:insert(pandoc.Str(')'))
 58 | 			acro_inlines:insert(1, pandoc.Space())
 59 | 			label = label:__concat(acro_inlines)
 60 | 
 61 | 		end
 62 | 
 63 | 		-- 'proof' statements are not defined
 64 | 		if kind == 'proof' then
 65 | 			-- nothing to be done
 66 | 
 67 | 		else
 68 | 
 69 | 			-- amsthm provides `newtheorem*` for unnumbered kinds
 70 | 			local latex_cmd = self.setup.options.amsthm and counter == 'none' 
 71 | 				and '\\newtheorem*' or '\\newtheorem'
 72 | 
 73 | 			-- LaTeX command:
 74 | 			-- \theoremstyle{style} (amsthm only)
 75 | 			-- \newtheorem{kind}{label}
 76 | 			-- \newtheorem{kind}[shared_counter]{label}
 77 | 			-- \newtheorem{kind}{label}[counter_within]
 78 | 
 79 | 			local inlines = pandoc.List:new()
 80 | 			if self.setup.options.amsthm then
 81 | 				inlines:insert(
 82 | 					pandoc.RawInline('latex','\\theoremstyle{'
 83 | 							.. self.setup.kinds[kind].style .. '}\n')
 84 | 					)
 85 | 			end
 86 | 			inlines:insert(
 87 | 				pandoc.RawInline('latex', latex_cmd .. '{'
 88 | 					.. kind ..'}')
 89 | 			)
 90 | 			if shared_counter then
 91 | 				inlines:insert(
 92 | 				  pandoc.RawInline('latex', '['..shared_counter..']')
 93 | 				)
 94 | 			end
 95 | 			inlines:insert(pandoc.RawInline('latex','{'))
 96 | 			inlines:extend(label)
 97 | 			inlines:insert(pandoc.RawInline('latex','}'))
 98 | 			if counter_within then
 99 | 				inlines:insert(
100 | 				  pandoc.RawInline('latex', '['..counter_within..']')
101 | 				)
102 | 			end
103 | 			blocks:insert(pandoc.Plain(inlines))
104 | 
105 | 		end
106 | 
107 | 	elseif format:match('html') then
108 | 
109 | 	else -- any other format, no way to define statement kinds
110 | 
111 | 	end
112 | 
113 | 	-- place the blocks in header_includes or return them
114 | 	if self.setup.options.define_in_header then
115 | 		if not self.setup.includes.header then
116 | 			self.setup.includes.header = pandoc.List:new()
117 | 		end
118 | 		self.setup.includes.header:extend(blocks)
119 | 		return {}
120 | 	else
121 | 		return blocks
122 | 	end
123 | 
124 | end
125 | 


--------------------------------------------------------------------------------
/src/Statement.write_label.lua:
--------------------------------------------------------------------------------
 1 | --- Statement:write_label write the statement's full label
 2 | -- If numbered, use the kind label and statement numbering.
 3 | -- If custom label and acronym, use them. Otherwise no label.
 4 | -- Uses
 5 | --	self.is_numbered to tell whether the statement is numbered
 6 | --	self.setup.options.swap_numbers to swap numbers
 7 | -- 	self.custom_label, if any
 8 | -- 	self.crossref_label if numbered, this contains the numbering
 9 | -- 	self.setup.kinds[self.kind].label the kind's label, if any
10 | --@return inlines statement label inlines
11 | function Statement:write_label()
12 | 	kinds = self.setup.kinds -- pointer to the kinds table
13 | 	bb, eb = '(', ')' 
14 | 	inlines = pandoc.List:new()
15 | 	
16 | 	if self.custom_label then
17 | 
18 | 		inlines:extend(self.custom_label)
19 | 		if self.acronym then
20 | 			inlines:insert(pandoc.Space())
21 | 			inlines:insert(pandoc.Str(bb))
22 | 			inlines:extend(self.acronym)			
23 | 			inlines:insert(pandoc.Str(eb))
24 | 		end
25 | 
26 | 	else
27 | 
28 | 		-- add kind label
29 | 		if kinds[self.kind] and kinds[self.kind].label then
30 | 			inlines:extend(kinds[self.kind].label)
31 | 		end
32 | 
33 | 		-- if numbered, add number from self.crossref_label
34 | 		-- before or after depending on `swamp_numbers`
35 | 		if self.is_numbered and self.crossref_label then
36 | 
37 | 			if self.setup.options.swap_numbers then
38 | 				if #inlines > 0 then
39 | 					inlines:insert(1, pandoc.Space())
40 | 				end
41 | 				inlines = self.crossref_label:__concat(inlines) 
42 | 			else
43 | 				if #inlines > 0 then
44 | 					inlines:insert(pandoc.Space())
45 | 				end
46 | 				inlines:extend(self.crossref_label)
47 | 			end
48 | 
49 | 		end
50 | 
51 | 	end
52 | 
53 | 	return inlines
54 | 
55 | end


--------------------------------------------------------------------------------
/src/Statement.write_latex.lua:
--------------------------------------------------------------------------------
 1 | ---Statement.write_latex: write a statement in LaTeX
 2 | -- \begin{kind}[info inlines] 
 3 | --		[Link(identifier)] content blocks
 4 | --	\end{kind}
 5 | --@return Blocks
 6 | function Statement:write_latex()
 7 | 	local blocks = pandoc.List:new()
 8 | 	local id_span -- a Span element to give the statement an identifier
 9 | 	local style_def = self.setup.styles[self.setup.kinds[self.kind].style]
10 | 
11 | 	-- we start with Plain block `\begin{...}[info]\hypertarget'
12 | 	local inlines = pandoc.List:new()
13 | 	inlines:insert(pandoc.RawInline('latex', 
14 | 						'\\begin{' .. self.kind .. '}'))
15 | 	-- if info, insert in brackets
16 | 	if self.info then
17 | 		inlines:insert(pandoc.RawInline('latex', '['))
18 | 		inlines:extend(self.info)
19 | 		inlines:insert(pandoc.RawInline('latex', ']'))
20 | 	end
21 | 	-- if the element has an identifier, insert an empty identifier Span 
22 | 	if self.identifier then
23 | 		inlines:insert(pandoc.Span({},pandoc.Attr(self.identifier)))
24 | 	end
25 | 	-- if the blocks start with a list and has a label, 
26 | 	-- amsthm needs to be told to start a newline
27 | 	-- if the style has a linebreak already, needs a negative baselineskip too
28 | 	if self.content[1] and self.content[1].t
29 | 		  and (self.label or self.custom_label)
30 | 			and (self.content[1].t == 'BulletList' or self.content[1].t == 'OrderedList'
31 | 				or self.content[1].t == 'DefinitionList') then
32 | 		inlines:insert(pandoc.RawInline('latex', '\\leavevmode'))
33 | 		if style_def.linebreak_after_head then
34 | 			inlines:insert(pandoc.RawInline('latex', '\\vspace{-\\baselineskip}'))
35 | 		end
36 | 	end
37 | 	-- insert \begin{...}[...] etc. as Plain block
38 | 	blocks:insert(pandoc.Plain(inlines))
39 | 
40 | 	-- main content
41 | 	blocks:extend(self.content)
42 | 
43 | 	-- close
44 | 	blocks:insert(pandoc.RawBlock('latex',
45 | 						'\\end{' .. self.kind .. '}'))
46 | 
47 | 	return blocks
48 | 
49 | end
50 | 
51 | 


--------------------------------------------------------------------------------
/src/Statement.write_native.lua:
--------------------------------------------------------------------------------
 1 | ---Statement.write_latex: write a statement in Pandoc native
 2 | -- We wrap the statement in a Div
 3 | --@return Blocks
 4 | function Statement:write_native()
 5 | 	local font_format_native = Helpers.font_format_native
 6 | 	-- pick the style definition for punctuation, linebreak after head...
 7 | 	local style_def = self.setup.styles[self.setup.kinds[self.kind].style]
 8 | 	-- convert font definitions into formatting functions
 9 | 	local label_format = font_format_native(style_def.head_font)
10 | 	local body_format = font_format_native(style_def.body_font)
11 | 	local label, heading
12 | 
13 | 	-- create label span; could be custom-label or kind label
14 | 	label = self:write_label() 
15 | 	if #label > 0 then
16 | 		label_span = pandoc.Span(label, 
17 | 											{class = 'statement-label'})
18 | 	end
19 | 
20 | 	-- prepare the statement heading inlines
21 | 	local heading = pandoc.List:new()
22 | 	-- label?
23 | 	label = self:write_label()
24 | 	if #label > 0 then
25 | 		label = label_format(label)
26 | 		label = pandoc.Span(label, {class = 'statement-label'})
27 | 		heading:insert(label)
28 | 	end
29 | 
30 | 	-- info?
31 | 	if self.info then
32 | 		if #heading > 0 then
33 | 			heading:insert(pandoc.Space())
34 | 		end
35 | 		heading:insert(pandoc.Str('('))
36 | 		heading:extend(self.info)
37 | 		heading:insert(pandoc.Str(')'))
38 | 	end
39 | 
40 | 	-- punctuation
41 | 		if #heading > 0 and style_def.punctuation then
42 | 			heading:insert(pandoc.Str(style_def.punctuation))
43 | 		end
44 | 
45 | 	-- style body
46 | 	-- must be done before we insert the heading to ensure
47 | 	-- that body_format isn't applied to the heading.
48 | --	print(pandoc.write(pandoc.Pandoc(self.content)))
49 | 	self.content = body_format(self.content)
50 | --	print(pandoc.write(pandoc.Pandoc(self.content)))
51 | 
52 | 	-- insert heading
53 | 	-- combine statement heading with the first paragraph if any
54 | 	-- take care of linebreak after head
55 | 	if #heading > 0 then
56 | 		if self.content[1] and self.content[1].t == 'Para' then
57 | 			if style_def.linebreak_after_head then
58 | 				heading:insert(pandoc.LineBreak())
59 | 			else
60 | 				heading:insert(pandoc.Space())
61 | 			end
62 | 			heading:extend(self.content[1].content)
63 | 			self.content[1] = pandoc.Para(heading)
64 | 		else
65 | 			self.content:insert(1, pandoc.Para(heading))
66 | 		end
67 | 	end
68 | 
69 | 	-- if the element has an identifier, insert an empty identifier Span 
70 | 	if self.identifier then
71 | 		id_span = pandoc.Span({},pandoc.Attr(self.identifier))
72 | 		if self.content[1] 
73 | 				and (self.content[1].t == 'Para' 
74 | 						or self.content[1].t == 'Plain') then
75 | 			self.content[1].content:insert(1, id_span)
76 | 		else
77 | 			self.content:insert(pandoc.Plain(id_span))
78 | 		end
79 | 	end
80 | 
81 | 	-- place all the content blocks in Div
82 | 	return pandoc.Blocks(pandoc.Div(self.content))
83 | 
84 | end


--------------------------------------------------------------------------------
/src/Walker.crossreferences.lua:
--------------------------------------------------------------------------------
 1 | ---Walker:crossreferences: creates a Blocks filter to 
 2 | -- handle crossreferences.
 3 | -- Links with empty content get crossref_label as their content
 4 | -- Uses:
 5 | --	self.setup.options.citations: whether to use citation syntax
 6 | --@return filter, table of functions (pandoc Filter)
 7 | function Walker:crossreferences()
 8 | 	local options = self.setup.options
 9 | 	local crossref = self.setup.crossref
10 | 	local filter = {}
11 | 
12 | 	filter.Link = function (link)
13 | 					return crossref:process(link)
14 | 				end
15 | 
16 | 	if options.citations then
17 | 		filter.Cite = function (cite)
18 | 						return crossref:process(cite)
19 | 					end
20 | 	end
21 | 
22 | 	return filter
23 | 
24 | end
25 | 


--------------------------------------------------------------------------------
/src/Walker.lua:
--------------------------------------------------------------------------------
 1 | -- # Walker class
 2 | 
 3 | --- Walker: class to hold methods that walk through the document
 4 | Walker = {}
 5 | 
 6 | !input Walker.walk -- process blocks
 7 | 
 8 | !input Walker.crossreferences -- filter to process crossreferences to statements
 9 | 
10 | !input Walker.statements_in_lists -- filter, LaTeX hack for statements within lists
11 | 
12 | -- Walker:new: create a Walker class object based on document's setup
13 | --@param setup a Setup class object
14 | --@param doc Pandoc document
15 | --@return Walker class object
16 | function Walker:new(setup, doc)
17 | 
18 | 	-- create an object of the Walker class
19 | 	local o = {}
20 | 	self.__index = self 
21 | 	setmetatable(o, self)
22 | 
23 | 	-- pointer to the setup table
24 | 	o.setup = setup
25 | 
26 | 	-- pointer to the blocks list
27 | 	o.blocks = doc.blocks
28 | 
29 | 	-- add crossreference manager to the setup
30 | 	o.setup.crossref = Crossref:new(doc, setup)
31 | 
32 | 	return o
33 | 
34 | end


--------------------------------------------------------------------------------
/src/Walker.statements_in_lists.lua:
--------------------------------------------------------------------------------
 1 | ---Walker.statements_in_lists: filter to handle statements within
 2 | -- lists in LaTeX.
 3 | -- In LaTeX a statement at the first line of a list item creates an
 4 | -- unwanted empty line. We wrap it in a LaTeX minipage to avoid this.
 5 | -- Uses
 6 | --		self.setup (passed to Statement:Div_is_statement)
 7 | --		self.setup.options.LaTeX_in_list_afterskip
 8 | -- @TODO This is hack, probably prevents page breaks within the statement
 9 | -- @TODO The skip below the statement is rigid, it should pick the
10 | -- skip that statement kind
11 | function Walker:statements_in_lists()
12 | 	filter = {}
13 | 
14 | 	-- wrap: wraps the first element of a list of blocks in a minipage.
15 |   -- store the `\parindent` value before, as minipage resets it to zero.
16 |   -- We will set \docparindent before the list to pick it up.
17 |   -- with minipage commands
18 |   local function wrap(blocks)
19 |     blocks:insert(1, pandoc.RawBlock('latex',
20 |       '\\begin{minipage}[t]{\\textwidth-\\itemindent-\\labelwidth}'
21 |       ..'\\parindent\\docparindent'
22 |       ))
23 |     blocks:insert(3, pandoc.RawBlock('latex',
24 |       '\\end{minipage}'
25 |       .. '\\vskip ' .. self.setup.options.LaTeX_in_list_afterskip
26 |       ))
27 |     -- add a right skip declaration within the statement Div
28 |     blocks[2].content:insert(1, pandoc.RawBlock('latex',
29 |       '\\addtolength{\\rightskip}{'
30 |       .. self.setup.options.LaTeX_in_list_rightskip .. '}'
31 |       )
32 |     )
33 | 
34 |     return blocks
35 |   end
36 | 
37 |   -- process: processes a BulletList or OrderedList element
38 |   -- return nil if nothing done
39 |   function process(elem)
40 |   	if FORMAT:match('latex') or FORMAT:match('native')
41 |     		or FORMAT:match('json') then
42 |  				
43 | 			local list_updated = false
44 | 	    -- go through list items, check if they start with a statement
45 |       for i = 1, #elem.content do
46 |         if elem.content[i][1] then
47 |           if elem.content[i][1].t and elem.content[i][1].t == 'Div'
48 |                 and Statement:Div_is_statement(elem.content[i][1],self.setup) then
49 |             elem.content[i] = wrap(elem.content[i])
50 |             list_updated = true
51 |           elseif elem.content[i][1].t and elem.content[i][1].t == 'DefinitionList' then
52 |             --@TODO handle DefinitionLists here 
53 |           end
54 |         end
55 |       end
56 | 
57 |       -- if list has been updated, we need to add a line at the beginning
58 |       -- to store the document's `\parindent` value
59 |       if list_updated == true then
60 |       	return pandoc.Blocks({
61 |           pandoc.RawBlock('latex',
62 |             '\\edef\\docparindent{\\the\\parindent}\n'),
63 |           elem      		
64 |       	})
65 |       end
66 | 
67 |     end
68 |   end
69 | 
70 |   -- return the filter
71 |   return {BulletList = process,
72 |   	OrderedList = process}
73 | 
74 | end


--------------------------------------------------------------------------------
/src/Walker.walk.lua:
--------------------------------------------------------------------------------
  1 | --- Walker:walk: walk through a list of blocks, processing statements
  2 | --@param blocks (optional) pandoc Blocks to be processed
  3 | --								defaults to self.blocks
  4 | function Walker:walk(blocks)
  5 | 	local blocks = blocks or self.blocks
  6 | 	-- recursion setup
  7 | 	-- NB, won't look for statements in table cells
  8 | 	-- element types with elem.content of Blocks type
  9 | 	local content_is_blocks = pandoc.List:new(
 10 | 															{'BlockQuote', 'Div', 'Note'})
 11 | 	-- element types with elem.content a list of Blocks type
 12 | 	local content_is_list_of_blocks = pandoc.List:new(
 13 | 							{'BulletList', 'DefinitionList', 'OrderedList'})
 14 | 	local result = pandoc.List:new()
 15 | 	local is_modified = false -- whether anything is changed in this doc
 16 | 
 17 | 	-- go through the blocks in order
 18 | 	--		- find headings and update counters
 19 | 	--		- find statements and process them
 20 | 	for _,block in ipairs(blocks) do
 21 | 
 22 | 		-- headers: increment counters if they exist
 23 | 		-- ignore 'unnumbered' headers: <https://pandoc.org/MANUAL.html#extension-header_attributes>
 24 | 		if self.setup.counters and block.t == 'Header' 
 25 | 			and not block.classes:includes('unnumbered') then
 26 | 
 27 | 				self.setup:increment_counter(block.level)
 28 | 				result:insert(block)
 29 | 
 30 | 		-- Divs: check if they are statements
 31 | 		elseif block.t == 'Div' then
 32 | 
 33 | 			-- try to create a statement
 34 | 			sta = Statement:new(block, self.setup)
 35 | 
 36 | 			-- replace the block with the formatted statement, if any
 37 | 			if sta then
 38 | 				result:extend(sta:write())
 39 | 				is_modified = true
 40 | 
 41 | 			-- if none, process the Div's contents
 42 | 			else
 43 | 
 44 | 				local sub_blocks = self:walk(block.content)
 45 | 				if sub_blocks then
 46 | 					block.content = sub_blocks
 47 | 					is_modified = true
 48 | 					result:insert(block)
 49 | 				else
 50 | 					result:insert(block)
 51 | 				end
 52 | 
 53 | 			end
 54 | 
 55 | 		-- ends Div block processing
 56 | 
 57 | 		-- DefinitionLists: scan for statements
 58 | 		-- The element is a list, each item is a pair (inlines, 
 59 | 		-- list of blocks). We need to check the list item per item,
 60 | 		-- split it if it contains statements, and process the
 61 | 		-- contents of non-statement items recursively.
 62 | 		elseif self.setup.options.definition_lists 
 63 | 						and block.t == 'DefinitionList' then
 64 | 
 65 | 			-- `previous_items`: store non-statement items one by one until
 66 | 			-- we encounter a statement 
 67 | 			local previous_items = pandoc.List:new() -- to store previous items
 68 | --			local block_modified = false -- any changes in this block?
 69 | 
 70 | 			for _,item in ipairs(block.content) do
 71 | 
 72 | 				-- if we succeed in creating a statement, flush out
 73 | 				-- any previous items in a DefinitionList and insert
 74 | 				-- the statement.
 75 | 				local successful_insert = false 
 76 | 				-- if item is supposed to be a statement, try parsing and insert.
 77 | 				-- note that Statement:new needs a single-item DefinitionList,
 78 | 				-- so we create one and pass it.
 79 | 				if Statement:DefListitem_is_statement(item, self.setup) then
 80 | 
 81 | 					-- try to parse
 82 | 					sta = Statement:new(pandoc.DefinitionList({item}), self.setup)
 83 | 					if sta then
 84 | 						-- if previous items, flush them out in a new DefinitionList
 85 | 						if #previous_items > 0 then
 86 | 							result:insert(pandoc.DefinitionList(previous_items))
 87 | 							previous_items = pandoc.List:new()
 88 | 						end
 89 | 						result:extend(sta:write())
 90 | 						is_modified = true
 91 | 						successful_insert = true
 92 | 					end
 93 | 				end
 94 | 
 95 | 				-- if not a statement or failed to parse, treat as 
 96 | 				-- standard DefinitionList item: process the contents
 97 | 				-- recursively and insert in previous items.
 98 | 				if not successful_insert then 
 99 | 
100 | 					-- recursively process the item's contents (list of Blocks)
101 | 					-- recall a DefinitionList item is a pair
102 | 					-- item[1] Inlines expression defined
103 | 					-- item[2] List of Blocks (list of lists of block elements)
104 | 					local new_content = pandoc.List:new()
105 | 					for _,blocks in ipairs(item[2]) do
106 | 						local sub_blocks = self:walk(blocks)
107 | 						if sub_blocks then
108 | 							is_modified = true
109 | 							new_content:insert(sub_blocks)
110 | 						else
111 | 							new_content:insert(blocks)
112 | 						end
113 | 					end
114 | 					-- if we've modified anything in the recursion, insert
115 | 					-- the new content
116 | 					if is_modified then
117 | 						item[2] = new_content
118 | 					end
119 | 
120 | 					-- store the item to be included in a future DefinitionList
121 | 					previous_items:insert(item)
122 | 
123 | 				end
124 | 
125 | 			end -- end of the item loop
126 | 
127 | 			-- if any previous_items left, insert as DefinitionList
128 | 
129 | 			if #previous_items > 0 then
130 | 				result:insert(pandoc.DefinitionList(previous_items))
131 | 				previous_items = pandoc.List:new()
132 | 			end
133 | 
134 | 		-- ends DefinitionList block processing
135 | 
136 | 		-- element with blocks content: process recursively
137 | 		elseif content_is_blocks:includes(block.t) then
138 | 
139 | 			local sub_blocks = self:walk(block.content)
140 | 			if sub_blocks then
141 | 				block.content = sub_blocks
142 | 				is_modified = true
143 | 				result:insert(block)
144 | 			else
145 | 				result:insert(block)
146 | 			end
147 | 
148 | 		-- element with list of blocks content: process recursively
149 | 		elseif content_is_list_of_blocks:includes(block.t) then
150 | 
151 | 			-- rebuild the list item by item, processing each
152 | 			local content = pandoc.List:new()
153 | 			for _,item in ipairs(block.content) do
154 | 				local sub_blocks = self:walk(item)
155 | 				if sub_blocks then
156 | 					is_modified = true
157 | 					content:insert(sub_blocks)
158 | 				else
159 | 					content:insert(item)
160 | 				end
161 | 			end
162 | 			if is_modified then
163 | 				block.content = content
164 | 				result:insert(block)
165 | 			else
166 | 				result:insert(block)
167 | 			end
168 | 
169 | 		else -- any other element, just insert the block
170 | 
171 | 			result:insert(block)
172 | 
173 | 		end
174 | 
175 | 	end
176 | 
177 | 	return is_modified and pandoc.Blocks(result) or nil
178 | 
179 | end


--------------------------------------------------------------------------------
/src/helpers.lua:
--------------------------------------------------------------------------------
 1 | ---Helpers class: helper functions
 2 | --This class collects helper functions that do not depend 
 3 | --on the filter's data structure.
 4 | Helpers = {}
 5 | 
 6 | -- # Global functions
 7 | 
 8 | stringify = pandoc.utils.stringify
 9 | 
10 | --- type: pandoc-friendly type function
11 | -- pandoc.utils.type is only defined in Pandoc >= 2.17
12 | -- if it isn't, we extend Lua's type function to give the same values
13 | -- as pandoc.utils.type on Meta objects: Inlines, Inline, Blocks, Block,
14 | -- string and boolean
15 | -- Caution: not to be used on non-Meta Pandoc elements, the 
16 | -- results will differ (only 'Block', 'Blocks', 'Inline', 'Inlines' in
17 | -- >=2.17, the .t string in <2.17).
18 | Helpers.type = pandoc.utils.type or function (obj)
19 |         local tag = type(obj) == 'table' and obj.t and obj.t:gsub('^Meta', '')
20 |         -- convert to Block, Blocks, Inline, Inlines
21 |         return tag and tag ~= 'Map' and tag or type(obj)
22 |     end
23 | type = Helpers.type
24 | 
25 | --- ensure_list: turns an element into a list if needed
26 | -- If elem is nil returns an empty list
27 | -- @param elem a Pandoc element
28 | -- @return a Pandoc List
29 | ensure_list = function (elem)
30 |     return type(elem) == 'List' and elem or pandoc.List:new({elem})
31 | end
32 | 
33 | ---message: send message to std_error
34 | -- @param type string INFO, WARNING, ERROR
35 | -- @param text string message text
36 | message = function (type, text)
37 |     local level = {INFO = 0, WARNING = 1, ERROR = 2}
38 |     if level[type] == nil then type = 'ERROR' end
39 |     if level[PANDOC_STATE.verbosity] <= level[type] then
40 |         io.stderr:write('[' .. type .. '] Collection lua filter: ' 
41 |             .. text .. '\n')
42 |     end
43 | end
44 | 
45 | -- ## Functions stored in Helpers fields
46 | 
47 | !input Helpers.font_format -- parse font features into formatting commands
48 | 
49 | !input Helpers.font_format_native -- parse font features into pandoc elements
50 | 
51 | !input Helpers.length_format -- parse a length in the desired format
52 | 
53 | 


--------------------------------------------------------------------------------
/src/main.lua:
--------------------------------------------------------------------------------
 1 | --[[-- # Statement - a Lua filter for statements in Pandoc's markdown
 2 | 
 3 | This Lua filter provides support for statements (principles,
 4 | arguments, vignettes, theorems, exercises etc.) in Pandoc's markdown.
 5 | 
 6 | @author Julien Dutant <julien.dutant@kcl.ac.uk>
 7 | @author Thomas Hodgson <hello@twshodgson.net>
 8 | @copyright 2021-2022 Julien Dutant, Thomas Hodgson
 9 | @license MIT - see LICENSE file for details.
10 | @release 0.5.1
11 | 
12 | ]]
13 | 
14 | -- # Global helper functions
15 | 
16 | !input Helpers -- global helper functions
17 | 
18 | -- # Filter components
19 | 
20 | !input Setup -- the Setup class
21 | 
22 | !input Statement -- the Statement class
23 | 
24 | !input Crossref -- the Crossref class
25 | 
26 | !input Walker -- the Walker class
27 | 
28 | -- # Main function
29 | 
30 | function main(doc) 
31 | 
32 | 	-- JATS writer requires pandoc.write
33 | 	-- font formatting in generic output requires 2.17 to work well
34 | 	-- not sure which is the lowest compatible version otherwise, 
35 | 	-- 2.14 is definitely enough, 2.12 should be good
36 | 	if FORMAT:match('jats') then
37 | 		PANDOC_VERSION:must_be_at_least '2.17'
38 | 	else 
39 | 		PANDOC_VERSION:must_be_at_least '2.12'
40 | 	end		
41 | 
42 | 	-- create a setup object that holds the filter settings
43 | 	local setup = Setup:new(doc.meta)
44 | 
45 | 	-- create a new document walker based on the setting
46 | 	local walker = Walker:new(setup, doc)
47 | 
48 | 	-- Protect statements in lists in LaTeX 
49 | 	-- by applying the `statement_in_lists` filter
50 | 	-- See this function for details.
51 | 	walker.blocks = pandoc.Blocks(walker.blocks):walk(walker:statements_in_lists())
52 | 
53 | 	-- walk the document; returns nil if no modification
54 | 	local blocks = walker:walk()
55 | 
56 | 	-- process crossreferences if statements were created
57 | 	if blocks then
58 | 		blocks = blocks:walk(walker:crossreferences())
59 | 	end
60 | 
61 | 	-- if the doc has been modified, update its meta and return it
62 | 	if blocks then
63 | 		doc.blocks = blocks
64 | 		doc.meta = setup:update_meta(doc.meta)
65 | 		return doc
66 | 	end
67 | end
68 | 
69 | --- Return main as a Pandoc element filter
70 | return {
71 | 	{
72 | 			Pandoc = main
73 | 	},
74 | }


--------------------------------------------------------------------------------
/tests/AMSthm-test-file-swap-numbers.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: Newtheorem and theoremstyle test
  3 | subtitle: recreated with the Pandoc Statement filter
  4 | author: Michael Downes, updated by Barbara Beeton
  5 | numbersections: true
  6 | linkcolor: blue
  7 | link-citations: true
  8 | statement:
  9 |     count-within: section
 10 |     swap-numbers: true
 11 | statement-kinds:
 12 |     remark:
 13 |         counter: none
 14 |     proposition:
 15 |         counter: self
 16 |     note:
 17 |         style: note
 18 |         counter: self
 19 |         label: Note
 20 |     varthm:
 21 |         style: citing
 22 |         counter: none
 23 |     bthm:
 24 |         style: break
 25 |         label: B-Theorem
 26 |         counter: self
 27 |     exercise:
 28 |         style: exercise
 29 |         label: Exercise
 30 |         counter: self
 31 | statement-styles:
 32 |     exercise:
 33 |         based-on: plain
 34 |         punctuation: ':'
 35 |     note:
 36 |         margin-top: 3pt
 37 |         margin-bottom: 3pt
 38 |         body-font: normal
 39 |         head-font: italics
 40 |         punctuation: ':'
 41 |         space-after-head: .5em
 42 |     citing:
 43 |         margin-top: 3pt
 44 |         margin-bottom: 3pt
 45 |         body-font: italics
 46 |         head-font: bold
 47 |         punctuation: '.'
 48 |         space-after-head: .5em
 49 |     break:
 50 |         margin-top: 9pt
 51 |         margin-bottom: 9pt
 52 |         body-font: italics
 53 |         head-font: bold
 54 |         punctuation: '.'
 55 |         space-after-head: \newline 
 56 | references:
 57 | - type: article-journal
 58 |   id: thatone
 59 |   author:
 60 |   - family: Dummy
 61 |     given: D.
 62 |   issued:
 63 |     date-parts:
 64 |     - - 1900
 65 |       - 1
 66 |       - 1
 67 |   title: 'Dummy reference'
 68 |   container-title: Journal
 69 |   volume: 1
 70 |   issue: 1
 71 |   page: 1-10
 72 | ---
 73 | 
 74 | # Test of standard theorem styles
 75 | 
 76 | Ahlfors' Lemma gives the principal criterion for obtaining lower bounds
 77 | on the Kobayashi metric.
 78 | 
 79 | ::: lemma
 80 | **Ahlfors' Lemma**. Let $ds^2 = h(z)|dz|^2$ be a Hermitian
 81 | pseudo-metric on $\mathbf{D}_r$, $h\in C^2(\mathbf{D}_r)$, with $\omega$
 82 | the associated $(1,1)$-form. If
 83 | $\mathop{\mathrm{Ric}}\nolimits\omega\geq\omega$ on $\mathbf{D}_r$, then
 84 | $\omega\leq\omega_r$ on all of $\mathbf{D}_r$ (or equivalently,
 85 | $ds^2\leq ds_r^2$).
 86 | :::
 87 | 
 88 | ::: lem
 89 | (negatively curved families) Let $\{ds_1^2,\dots,ds_k^2\}$
 90 | be a negatively curved family of metrics on $\mathbf{D}_r$, with
 91 | associated forms $\omega^1$, ..., $\omega^k$. Then
 92 | $\omega^i \leq\omega_r$ for all $i$.
 93 | :::
 94 | 
 95 | Then our main theorem:
 96 | 
 97 | ::: {.theorem #sdq}
 98 | Let $d_{\max}$ and $d_{\min}$ be the maximum,
 99 | resp. minimum distance between any two adjacent vertices of a
100 | quadrilateral $Q$. Let $\sigma$ be the diagonal pigspan of a pig $P$
101 | with four legs. Then $P$ is capable of standing on the corners of $Q$
102 | iff $$\label{sdq}
103 | \sigma\geq \sqrt{d_{\max}^2+d_{\min}^2}.$$
104 | :::
105 | 
106 | ::: corollary
107 | Admitting reflection and rotation, a three-legged pig
108 | $P$ is capable of standing on the corners of a triangle $T$ iff
109 | @sdq holds.
110 | :::
111 | 
112 | ::: {.remark .unnumbered}
113 | As two-legged pigs generally fall over, the case of a
114 | polygon of order $2$ is uninteresting.
115 | :::
116 | 
117 | # Custom theorem styles
118 | 
119 | ::: exercise
120 | Generalize Theorem @sdq to three and four dimensions.
121 | :::
122 | 
123 | ::: note
124 | This is a test of the custom theorem style `note`. It is
125 | supposed to have variant fonts and other differences.
126 | :::
127 | 
128 | ::: bthm
129 | Test of the 'linebreak' style of theorem heading.
130 | :::
131 | 
132 | This is a test of a citing theorem to cite a theorem from some other
133 | source.
134 | 
135 | ::: varthm
136 | (Theorem 3.6 in @thatone). No hyperlinking available here yet 
137 | but that's not a bad idea for the future.
138 | :::
139 | 
140 | # The proof environment
141 | 
142 | ::: proof
143 | Here is a test of the proof environment.
144 | :::
145 | 
146 | ::: proof
147 | (Proof of Theorem @sdq) And another test.
148 | :::
149 | 
150 | ::: proof
151 | (Proof of *necessity*) And another.
152 | :::
153 | 
154 | ::: proof
155 | (Proof of *sufficiency*)  And another, ending with
156 | a display: $$1+1=2\,. \qedhere$$
157 | :::
158 | 
159 | # References


--------------------------------------------------------------------------------
/tests/AMSthm-test-file.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: Newtheorem and theoremstyle test
  3 | subtitle: recreated with the Pandoc Statement filter
  4 | author: Michael Downes, updated by Barbara Beeton
  5 | numbersections: true # LaTeX only, in HTML use -N or --number-sections
  6 | linkcolor: blue
  7 | link-citations: true
  8 | statement:
  9 |     count-within: section
 10 | statement-kinds:
 11 |     remark:
 12 |         counter: none
 13 |     proposition:
 14 |         counter: self
 15 |     note:
 16 |         style: note
 17 |         counter: self
 18 |         label: Note
 19 |     varthm:
 20 |         style: citing
 21 |         counter: none
 22 |     bthm:
 23 |         style: break
 24 |         label: B-Theorem
 25 |         counter: self
 26 |     exercise:
 27 |         style: exercise
 28 |         label: Exercise
 29 |         counter: self
 30 | statement-styles:
 31 |     exercise:
 32 |         based-on: plain
 33 |         punctuation: ':'
 34 |     note:
 35 |         margin-top: 3pt
 36 |         margin-bottom: 3pt
 37 |         body-font: normal
 38 |         head-font: italics
 39 |         punctuation: ':'
 40 |         space-after-head: .5em
 41 |     citing:
 42 |         margin-top: 3pt
 43 |         margin-bottom: 3pt
 44 |         body-font: italics
 45 |         head-font: bold
 46 |         punctuation: '.'
 47 |         space-after-head: .5em
 48 |         head_spec_latex: '\thmnote{#3}'
 49 |     break:
 50 |         margin-top: 9pt
 51 |         margin-bottom: 9pt
 52 |         body-font: italics
 53 |         head-font: bold
 54 |         punctuation: '.'
 55 |         space-after-head: \n 
 56 | references:
 57 | - type: article-journal
 58 |   id: thatone
 59 |   author:
 60 |   - family: Dummy
 61 |     given: D.
 62 |   issued:
 63 |     date-parts:
 64 |     - - 1900
 65 |       - 1
 66 |       - 1
 67 |   title: 'Dummy reference'
 68 |   container-title: Journal
 69 |   volume: 1
 70 |   issue: 1
 71 |   page: 1-10
 72 |   DOI: 10.1038/171737a0
 73 | ---
 74 | 
 75 | # Test of standard theorem styles
 76 | 
 77 | Ahlfors' Lemma gives the principal criterion for obtaining lower bounds
 78 | on the Kobayashi metric.
 79 | 
 80 | ::: lemma
 81 | **Ahlfors's Lemma**. Let $ds^2 = h(z)|dz|^2$ be a Hermitian
 82 | pseudo-metric on $\mathbf{D}_r$, $h\in C^2(\mathbf{D}_r)$, with $\omega$
 83 | the associated $(1,1)$-form. If
 84 | $\mathop{\mathrm{Ric}}\nolimits\omega\geq\omega$ on $\mathbf{D}_r$, then
 85 | $\omega\leq\omega_r$ on all of $\mathbf{D}_r$ (or equivalently,
 86 | $ds^2\leq ds_r^2$).
 87 | :::
 88 | 
 89 | ::: lem
 90 | (negatively curved families) Let $\{ds_1^2,\dots,ds_k^2\}$
 91 | be a negatively curved family of metrics on $\mathbf{D}_r$, with
 92 | associated forms $\omega^1$, ..., $\omega^k$. Then
 93 | $\omega^i \leq\omega_r$ for all $i$.
 94 | :::
 95 | 
 96 | Then our main theorem:
 97 | 
 98 | ::: {.theorem #pigspan}
 99 | Let $d_{\max}$ and $d_{\min}$ be the maximum,
100 | resp.\ minimum distance between any two adjacent vertices of a
101 | quadrilateral $Q$. Let $\sigma$ be the diagonal pigspan of a pig $P$
102 | with four legs. Then $P$ is capable of standing on the corners of $Q$
103 | iff 
104 | $$\sigma\geq \sqrt{d_{\max}^2+d_{\min}^2}.$$ {#sdq}
105 | :::
106 | 
107 | ::: corollary
108 | Admitting reflection and rotation, a three-legged pig
109 | $P$ is capable of standing on the corners of a triangle $T$ iff
110 | @sdq holds.
111 | :::
112 | 
113 | ::: {.remark .unnumbered}
114 | As two-legged pigs generally fall over, the case of a
115 | polygon of order $2$ is uninteresting.
116 | :::
117 | 
118 | # Custom theorem styles
119 | 
120 | ::: exercise
121 | Generalize Theorem\ @pigspan to three and four dimensions.
122 | :::
123 | 
124 | ::: note
125 | This is a test of the custom theorem style `note`. It is
126 | supposed to have variant fonts and other differences.
127 | :::
128 | 
129 | ::: bthm
130 | Test of the 'linebreak' style of theorem heading.
131 | :::
132 | 
133 | This is a test of a citing theorem to cite a theorem from some other
134 | source.
135 | 
136 | ::: varthm
137 | (Theorem 3.6 in @thatone). No hyperlinking available here yet 
138 | but that's not a bad idea for the future.
139 | :::
140 | 
141 | # The proof environment
142 | 
143 | ::: proof
144 | Here is a test of the proof environment.
145 | :::
146 | 
147 | ::: proof
148 | (Proof of Theorem @pigspan) And another test.
149 | :::
150 | 
151 | ::: proof
152 | (Proof of *necessity*) And another.
153 | :::
154 | 
155 | ::: proof
156 | (Proof of *sufficiency*)  And another, ending with
157 | a display: $$1+1=2\,. \qedhere$$
158 | :::
159 | 
160 | # References


--------------------------------------------------------------------------------
/tests/Linebreak_theorem_style.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Linebreak style in Statement
 3 | abstract: Tests various ways of defining a theorem
 4 | 	style with a linebreak after the theorem's head.
 5 | statement-styles:
 6 | 	break1: 
 7 | 		based_on: plain
 8 | 		space_after_head: '\n'
 9 | 	break2: 
10 | 		based_on: plain
11 | 		space_after_head: \n
12 | 	break3: 
13 | 		based_on: plain
14 | 		space_after_head: \newline
15 | statement:
16 | 	break1: B1-Theorem
17 | 	break2: B2-Theorem
18 | 	break3: B3-Theorem
19 | ---
20 | 
21 | B1-Theorem.
22 | : test
23 | 
24 | B2-Theorem.
25 | : test
26 | 
27 | B3-Theorem.
28 | : test
29 | 
30 | ::: B1-Theorem
31 | * list
32 | * test
33 | :::
34 | 
35 | ::: B2-Theorem
36 | * list
37 | * test
38 | :::
39 | 


--------------------------------------------------------------------------------
/tests/Lists_in_theorems.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Lists in theorems with the Statement filter
 3 | abstract: This tests how the Statement handles
 4 | 	lists within theorems. These sometimes create
 5 | 	formatting issues for the AMS theorems package
 6 | 	in LaTeX.
 7 | ---
 8 | 
 9 | ::: thm
10 | * first item
11 | * second item
12 | 
13 | A theorem with a bullet list.
14 | :::
15 | 
16 | ::: thm
17 | 1. first item
18 | 2. second item.
19 | 
20 | A theorem with an ordered list.
21 | :::
22 | 
23 | ::: thm
24 | (this theorem has some info too)
25 | 
26 | * first item
27 | * second item
28 | :::
29 | 
30 | ::: thm
31 | **Custom labelled theorem** (with info)
32 | 
33 | * first item
34 | * second item
35 | :::
36 | 
37 | The following is a statement without label:
38 | 
39 | ::: statement
40 | * This statement should *not* start with
41 | * a `\newline` because it has no label
42 | :::
43 | 
44 | ::: proof
45 | * first item
46 | * second item
47 | 
48 | Bullet list within proof.
49 | :::
50 | 
51 | ::: proof
52 | 1. first item
53 | 2. second item
54 | 
55 | Numbered list within proof.
56 | :::
57 | 
58 | ::: proof
59 | 1. This proofs ends with
60 | 2. the list's last item.
61 | :::
62 | 
63 | ::: thm
64 | (Definition lists within theorems)
65 | 
66 | This theorem
67 | : illustrates a DefinitionList within a theorem.
68 | : The first item has two definitions.
69 | 
70 | The second item
71 | : has only one definition.
72 | :::


--------------------------------------------------------------------------------
/tests/Makefile:
--------------------------------------------------------------------------------
 1 | ROOT = ../# repository's root
 2 | INFO = quiet # use make INFO=verbose to get Pandoc verbose output
 3 | SRC_FILES = $(wildcard $(ROOT)src/*.lua)
 4 | TEST_FILES = $(wildcard *.md)
 5 | LATEX_TARGETS = $(patsubst %.md,%.tex,$(TEST_FILES))
 6 | PDF_TARGETS = $(patsubst %.md,%.pdf,$(TEST_FILES))
 7 | HTML_TARGETS = $(patsubst %.md,%.html,$(TEST_FILES))
 8 | JATS_TARGETS = $(patsubst %.md,%.xml,$(TEST_FILES))
 9 | DOCX_TARGETS = $(patsubst %.md,%.docx,$(TEST_FILES))
10 | NATIVE_TARGETS = $(patsubst %.md,%.native,$(TEST_FILES))
11 | 
12 | .PHONY:
13 | 
14 | $(ROOT)statement.lua: $(SRC_FILES) $(ROOT)lua-builder/lua-builder.lua
15 | 	@lua $(ROOT)lua-builder/lua-builder.lua $(ROOT)src/main.lua \
16 | 		-o $(ROOT)statement.lua --verbose --recursive
17 | 
18 | all: allbutpdf pdf
19 | 
20 | allbutpdf: tex html jats docx
21 | 
22 | tex: $(LATEX_TARGETS)
23 | 
24 | pdf: $(PDF_TARGETS)
25 | 
26 | html: $(HTML_TARGETS)
27 | 
28 | jats: $(JATS_TARGETS)
29 | 
30 | docx: $(DOCX_TARGETS)
31 | 
32 | native: $(NATIVE_TARGETS)
33 | 
34 | number_offset.html : number_offset.md $(ROOT)statement.lua
35 | 	@echo Generating $@
36 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
37 | 		--number-offset=2,2,2 \
38 | 		--top-level-division=chapter \
39 | 		--mathjax --number-sections --citeproc --to=html --output $@
40 | 
41 | automatic_locale.tex : automatic_locale.md $(ROOT)statement.lua
42 | 	@echo Generating $@
43 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
44 | 		--pdf-engine lualatex \
45 | 		--number-sections --citeproc --to=latex --output $@
46 | 
47 | automatic_locale.pdf : automatic_locale.md $(ROOT)statement.lua
48 | 	@echo Generating $@
49 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
50 | 		--pdf-engine lualatex \
51 | 		--number-sections --citeproc --to=pdf --output $@
52 | 
53 | %.tex: %.md $(ROOT)statement.lua
54 | 	@echo Generating $@
55 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
56 | 		--number-sections --citeproc --to=latex --output $@
57 | 
58 | %.pdf: %.md $(ROOT)statement.lua
59 | 	@echo Generating $@
60 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
61 | 		--number-sections --citeproc --to=pdf --output $@
62 | 
63 | %.html: %.md $(ROOT)statement.lua
64 | 	@echo Generating $@
65 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
66 | 		--mathjax --number-sections --citeproc --to=html --output $@
67 | 
68 | %.xml: %.md $(ROOT)statement.lua
69 | 	@echo Generating $@
70 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
71 | 		--citeproc --to=jats --output $@
72 | 
73 | %.docx: %.md $(ROOT)statement.lua
74 | 	@echo Generating $@
75 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
76 | 		--number-sections --citeproc --to=docx --output $@
77 | 
78 | %.native: %.md $(ROOT)statement.lua
79 | 	@echo Generating $@
80 | 	@pandoc $< --lua-filter $(ROOT)statement.lua -s --$(INFO) \
81 | 		--number-sections --citeproc --to=native --output $@
82 | 
83 | clean: 
84 | 	@echo Cleaning up generated files
85 | 	@rm -f $(LATEX_TARGETS) $(PDF_TARGETS) $(HTML_TARGETS) \
86 | 			$(JATS_TARGETS) $(DOCX_TARGETS) $(NATIVE_TARGETS)


--------------------------------------------------------------------------------
/tests/aliases.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | statement-kinds:
 3 |     proposition:
 4 |         aliases: [alias2, alias3]
 5 |     theorem:
 6 |         aliases: alias1
 7 | ---
 8 | 
 9 | ::: prop
10 | Standard prefixes, like `prop`, are recognized as aliases for `proposition`.
11 | :::
12 | 
13 | ::: alias1
14 | We can also define a custom alias, like `alias1`.
15 | :::
16 | 
17 | ::: alias2
18 | Or even provide a list of aliases, like `[alias2, alias3`.
19 | :::
20 | 
21 | ::: alias3
22 | Here the latter two are aliases for `proposition`.
23 | :::
24 | 


--------------------------------------------------------------------------------
/tests/automatic_locale.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Στοιχεῖα
 3 | author: Εὐκλείδης
 4 | lang: el
 5 | statement-kinds:
 6 |     Αίτημα: 
 7 |         label: Αίτημα
 8 | abstract: Automatic localisation with the statement filter.
 9 |     Requires a font with Greek characters (trying Times New Roman here) and `--pdf-engine lualatex`. Definitions (Ορισμός) and propositions (Πρόταση)
10 |     re recognized automatically. The postulate (Αίτημα) statement kind 
11 |     is defined in the preamble.
12 | mainfont: Times New Roman
13 | ---
14 | 
15 | ::: Ορισμός
16 | σημεῖόν ἐστιν, οὗ μέρος οὐθέν.
17 | :::
18 | 
19 | <!-- note that you can still use the english kinds names and prefixes -->
20 | ::: definition
21 | γραμμὴ δὲ μῆκος ἀπλατές.
22 | :::
23 | 
24 | ::: Ορισμός
25 | γραμμῆς δὲ πέρατα σημεῖα.
26 | :::
27 | 
28 | ::: Αίτημα
29 | Ἠιτήσθω ἀπὸ παντὸς σημείου ἐπὶ πᾶν σημεῖον εὐθεῖαν γραμμὴν ἀγαγεῖν.
30 | :::
31 | 
32 | ::: Αίτημα
33 | καὶ πεπερασμένην εὐθεῖαν κατὰ τὸ συνεχὲς ἐπ᾽ εὐθείας ἐκβαλεῖν.
34 | ::: 
35 | 
36 | ::: Αίτημα
37 | καὶ ἐὰν εἰς δύο εὐθείας εὐθεῖα ἐμπίπτουσα τὰς ἐντὸς καὶ ἐπὶ τὰ αὐτὰ μέρη γωνίας δύο ὀρθῶν ἐλάσσονας ποιῇ, ἐκβαλλομένας τὰς δύο εὐθείας ἐπ᾽ ἄπειρον συμπίπτειν, ἐφ᾽ ἃ μέρη εἰσὶν αἱ τῶν δύο ὀρθῶν ἐλάσσονες.
38 | :::
39 | 
40 | ::: Πρόταση
41 | ἐπὶ τῆς δοθείσης εὐθείας πεπερασμένης τρίγωνον ἰσόπλευρον συστήσασθαι. 
42 | :::


--------------------------------------------------------------------------------
/tests/benchmark_pandoc-amsthm.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: Statement and Pandoc-amsthm benchmark
  3 | abstract: Document used to measure the performance
  4 |     of the Statement filter against that of
  5 |     [Pandoc-amsthm](https://github.com/ickc/pandoc-amsthm).
  6 | amsthm:
  7 |     plain: [Theorem, Lemma]
  8 |     definition: [Definition]
  9 |     remark: [Remark]
 10 | ---
 11 | 
 12 | Example result (use `pandoc --verbose`):
 13 | 
 14 | * `pandoc-amsthm` 19ms
 15 | * `statement`: 40ms
 16 | 
 17 | ::: Theorem
 18 | All work and no play make Jack a dull boy
 19 | :::
 20 | 
 21 | ::: Lemma
 22 | All work and no play make Jack a dull boy
 23 | :::
 24 | 
 25 | ::: Definition
 26 | All work and no play make Jack a dull boy
 27 | :::
 28 | 
 29 | ::: Remark
 30 | All work and no play make Jack a dull boy
 31 | :::
 32 | 
 33 | ::: proof
 34 | All work and no play make Jack a dull boy
 35 | :::
 36 | 
 37 | ::: Theorem
 38 | All work and no play make Jack a dull boy
 39 | :::
 40 | 
 41 | ::: Lemma
 42 | All work and no play make Jack a dull boy
 43 | :::
 44 | 
 45 | ::: Definition
 46 | All work and no play make Jack a dull boy
 47 | :::
 48 | 
 49 | ::: Remark
 50 | All work and no play make Jack a dull boy
 51 | :::
 52 | 
 53 | ::: proof
 54 | All work and no play make Jack a dull boy
 55 | :::
 56 | 
 57 | ::: Theorem
 58 | All work and no play make Jack a dull boy
 59 | :::
 60 | 
 61 | ::: Lemma
 62 | All work and no play make Jack a dull boy
 63 | :::
 64 | 
 65 | ::: Definition
 66 | All work and no play make Jack a dull boy
 67 | :::
 68 | 
 69 | ::: Remark
 70 | All work and no play make Jack a dull boy
 71 | :::
 72 | 
 73 | ::: proof
 74 | All work and no play make Jack a dull boy
 75 | :::
 76 | 
 77 | ::: Theorem
 78 | All work and no play make Jack a dull boy
 79 | :::
 80 | 
 81 | ::: Lemma
 82 | All work and no play make Jack a dull boy
 83 | :::
 84 | 
 85 | ::: Definition
 86 | All work and no play make Jack a dull boy
 87 | :::
 88 | 
 89 | ::: Remark
 90 | All work and no play make Jack a dull boy
 91 | :::
 92 | 
 93 | ::: proof
 94 | All work and no play make Jack a dull boy
 95 | :::
 96 | 
 97 | ::: Theorem
 98 | All work and no play make Jack a dull boy
 99 | :::
100 | 
101 | ::: Lemma
102 | All work and no play make Jack a dull boy
103 | :::
104 | 
105 | ::: Definition
106 | All work and no play make Jack a dull boy
107 | :::
108 | 
109 | ::: Remark
110 | All work and no play make Jack a dull boy
111 | :::
112 | 
113 | ::: proof
114 | All work and no play make Jack a dull boy
115 | :::
116 | 
117 | ::: Theorem
118 | All work and no play make Jack a dull boy
119 | :::
120 | 
121 | ::: Lemma
122 | All work and no play make Jack a dull boy
123 | :::
124 | 
125 | ::: Definition
126 | All work and no play make Jack a dull boy
127 | :::
128 | 
129 | ::: Remark
130 | All work and no play make Jack a dull boy
131 | :::
132 | 
133 | ::: proof
134 | All work and no play make Jack a dull boy
135 | :::
136 | 
137 | ::: Theorem
138 | All work and no play make Jack a dull boy
139 | :::
140 | 
141 | ::: Lemma
142 | All work and no play make Jack a dull boy
143 | :::
144 | 
145 | ::: Definition
146 | All work and no play make Jack a dull boy
147 | :::
148 | 
149 | ::: Remark
150 | All work and no play make Jack a dull boy
151 | :::
152 | 
153 | ::: proof
154 | All work and no play make Jack a dull boy
155 | :::
156 | 
157 | ::: Theorem
158 | All work and no play make Jack a dull boy
159 | :::
160 | 
161 | ::: Lemma
162 | All work and no play make Jack a dull boy
163 | :::
164 | 
165 | ::: Definition
166 | All work and no play make Jack a dull boy
167 | :::
168 | 
169 | ::: Remark
170 | All work and no play make Jack a dull boy
171 | :::
172 | 
173 | ::: proof
174 | All work and no play make Jack a dull boy
175 | :::
176 | 
177 | ::: Theorem
178 | All work and no play make Jack a dull boy
179 | :::
180 | 
181 | ::: Lemma
182 | All work and no play make Jack a dull boy
183 | :::
184 | 
185 | ::: Definition
186 | All work and no play make Jack a dull boy
187 | :::
188 | 
189 | ::: Remark
190 | All work and no play make Jack a dull boy
191 | :::
192 | 
193 | ::: proof
194 | All work and no play make Jack a dull boy
195 | :::
196 | 
197 | ::: Theorem
198 | All work and no play make Jack a dull boy
199 | :::
200 | 
201 | ::: Lemma
202 | All work and no play make Jack a dull boy
203 | :::
204 | 
205 | ::: Definition
206 | All work and no play make Jack a dull boy
207 | :::
208 | 
209 | ::: Remark
210 | All work and no play make Jack a dull boy
211 | :::
212 | 
213 | ::: proof
214 | All work and no play make Jack a dull boy
215 | :::
216 | 
217 | ::: Theorem
218 | All work and no play make Jack a dull boy
219 | :::
220 | 
221 | ::: Lemma
222 | All work and no play make Jack a dull boy
223 | :::
224 | 
225 | ::: Definition
226 | All work and no play make Jack a dull boy
227 | :::
228 | 
229 | ::: Remark
230 | All work and no play make Jack a dull boy
231 | :::
232 | 
233 | ::: proof
234 | All work and no play make Jack a dull boy
235 | :::


--------------------------------------------------------------------------------
/tests/define_kinds_by_style.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Statements by kind
 3 | author: Julien Dutant
 4 | subtitle: Define statement kinds by their style
 5 | 			with the Statement filter
 6 | abstract: In this document statement kinds are defined
 7 | 	in lists, one per style. This works with predefined
 8 | 	styles (`plain`, `remark`, `definition`) as well
 9 | 	as user-defined ones (`mystyle`).
10 | statement:
11 | 	plain:
12 | 	- My First Kind
13 | 	- My Second Kind
14 | 	definition: [Explanation, Elaboration]
15 | 	remark: Digression
16 | 	mystyle: My Custom Kind
17 |     plain-unnumbered: [Aside, 'Little Known Fact']
18 | statement-styles:
19 | 	mystyle:
20 | 		based-on: plain
21 | 		space-after-head: 3em
22 |         margin-left: 1em
23 |         margin-right: 1em
24 | ---
25 | 
26 | My_First_Kind.
27 | : This is a statement of the first kind. Note that if our
28 |   kind label has spaces or special chars, I must replace
29 |   them with '_'.
30 | 
31 | My_Second_Kind.
32 | : This is a statement of the second kind.
33 | 
34 | My_Custom_Kind.
35 | : This is a statement of my custom kind, in the new `mystyle` style.
36 | 
37 | Explanation.
38 | : This is a statement of the Explanation kind, `definition` style.
39 | 
40 | Elaboration.
41 | : This is a statement of the Elaboration kind, `definition` style.
42 | 
43 | Digression.
44 | : This is a statement of the Elaboration kind, `remark` style.
45 | 
46 | Aside.
47 | : This statement is based on `plain`, but unnumbered.
48 | 
49 | Little_Known_Fact.
50 | : This statement is based on `plain` and unnumbered.


--------------------------------------------------------------------------------
/tests/documentation_examples.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Source for Statement documentation examples.
 3 | abstract: Use this to regenerate the documentation's images.
 4 | numbersections: true # LaTeX only, in HTML use -N or --number-sections
 5 | linkcolor: blue
 6 | ---
 7 | 
 8 | Theorem. (from Spivak 1967) {#fthc}
 9 | : Let $f$ be integrable on $[a,b]$, and define $F$ on $[a,b]$ by
10 | 
11 |     $$F(x) = \int_a^x f.$$
12 | 
13 |     If $f$ is continuous at $c$ in $[a,b]$ then $F$ is differentiable
14 |     at $c$, and
15 | 
16 |     $$F'(c) = f(c).$$
17 | 
18 |     (If $c = a$ or $b$, then $F'(c)$ is understood to mean the right-
19 |     or left-hand derivative of $F$.)
20 | 
21 | @Pre:fthc is known as the fundamental theorem of calculus.
22 | 
23 | ::: theorem
24 | (Pythagoras) The sum of angles in a triangle is equal to 
25 | two right angles.
26 | :::
27 | 
28 | ::: {.theorem #quadratic}
29 | The solutions of a quadratric equation $ax^2 + bx + c$ 
30 | are given by: 
31 | $$x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$$
32 | :::
33 | 
34 | ::: corollary
35 | A quadratic equation $ax^2 + bx + c$ has two real solutions 
36 | if and only if $b^2 - 4ac > 0$.
37 | :::
38 | 
39 | ::: proof
40 | Obvious from @quadratic.
41 | :::
42 | 


--------------------------------------------------------------------------------
/tests/number_offset.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: Testing counters
  3 | abstract: If this document is set to a book class, 
  4 |     or if Pandoc's  `--top-level-division` 
  5 |     is set to `chapter`,
  6 |     the theorem counter is attached to level 2 
  7 |     headings rather than level 1 ones. 
  8 |     In HTML output, the numbers are offset with
  9 |     Pandoc's `--number-offset` writer option. 
 10 | statement-kinds:
 11 |     theorem:
 12 |         counter: section
 13 |     proposition:
 14 |         counter: subsection
 15 |     lemma:
 16 |         counter: subsubsection
 17 | ---
 18 | 
 19 | # Level 1
 20 | 
 21 | ## Level 2
 22 | 
 23 | ### Level 3
 24 | 
 25 | ::: thm
 26 | Theorems are counted with sections.
 27 | :::
 28 | 
 29 | ::: prop
 30 | Theorems are counted with subsections.
 31 | :::
 32 | 
 33 | ::: lem
 34 | Test of this statement's counter.
 35 | :::
 36 | 
 37 | ### Level 3
 38 | 
 39 | ::: thm
 40 | Test of this statement's counter.
 41 | :::
 42 | 
 43 | ::: prop
 44 | Test of this statement's counter.
 45 | :::
 46 | 
 47 | ::: lem
 48 | Test of this statement's counter.
 49 | :::
 50 | 
 51 | ## Level 2
 52 | 
 53 | ### Level 3
 54 | 
 55 | ::: thm
 56 | Test of this statement's counter.
 57 | :::
 58 | 
 59 | ::: prop
 60 | Test of this statement's counter.
 61 | :::
 62 | 
 63 | ::: lem
 64 | Test of this statement's counter.
 65 | :::
 66 | 
 67 | ### Level 3
 68 | 
 69 | ::: thm
 70 | Test of this statement's counter.
 71 | :::
 72 | 
 73 | ::: prop
 74 | Test of this statement's counter.
 75 | :::
 76 | 
 77 | ::: lem
 78 | Test of this statement's counter.
 79 | :::
 80 | 
 81 | # Level 1
 82 | 
 83 | ## Level 2
 84 | 
 85 | ### Level 3
 86 | 
 87 | ::: thm
 88 | Theorems are counted with sections.
 89 | :::
 90 | 
 91 | ::: prop
 92 | Theorems are counted with subsections.
 93 | :::
 94 | 
 95 | ::: lem
 96 | Test of this statement's counter.
 97 | :::
 98 | 
 99 | ### Level 3
100 | 
101 | ::: thm
102 | Test of this statement's counter.
103 | :::
104 | 
105 | ::: prop
106 | Test of this statement's counter.
107 | :::
108 | 
109 | ::: lem
110 | Test of this statement's counter.
111 | :::
112 | 
113 | ## Level 2
114 | 
115 | ### Level 3
116 | 
117 | ::: thm
118 | Test of this statement's counter.
119 | :::
120 | 
121 | ::: prop
122 | Test of this statement's counter.
123 | :::
124 | 
125 | ::: lem
126 | Test of this statement's counter.
127 | :::
128 | 
129 | ### Level 3
130 | 
131 | ::: thm
132 | Test of this statement's counter.
133 | :::
134 | 
135 | ::: prop
136 | Test of this statement's counter.
137 | :::
138 | 
139 | ::: lem
140 | Test of this statement's counter.
141 | :::
142 | 


--------------------------------------------------------------------------------
/tests/principles_vignettes.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: Principles and vignettes with the 
  3 |     Statement filter
  4 | abstract: Demonstrates two markdown syntaxes
  5 |   for principles or vignettes with optional label, 
  6 |   acronym and info, and for crossreferencing them.
  7 | linkcolor: blue
  8 | link-citations: true
  9 | statement-styles:
 10 |   break:
 11 |     based-on: empty
 12 |     space-after-head: '\n'
 13 |     punctuation: ''
 14 |     custom-label-changes: 
 15 |         punctuation: ''
 16 | statement-kinds:
 17 |   statement-break:
 18 |     based-on: statement
 19 |     style: break
 20 | ---
 21 | 
 22 | # Div syntax
 23 | 
 24 | The statements in this section are entered in markdown using the
 25 | Div syntax. (We'll continue the text a bit to establish the
 26 | text width.)
 27 | 
 28 | ::: statement
 29 | 
 30 | This statement will be rendered as simple indented text. Curabitur dictum gravida mauris. Nam arcu libero, nonummy eget, consectetuer id, vulputate a, magna. 
 31 | 
 32 | * It contains two paragraphs
 33 | * and a list.
 34 | 
 35 | Donec vehicula augue eu neque. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Mauris ut leo.
 36 | 
 37 | :::
 38 | 
 39 | The statement below has a custom label. The label is automatically
 40 | turned into an ID that can be used to 
 41 | [reference it](#the-principal-principle).
 42 | 
 43 | ::: statement
 44 | **The Principal Principle**. One's credence in $p$ conditional
 45 | on the hypothesis that the chance of $p$ is $x$ should be $x$.
 46 | :::
 47 | 
 48 | The statement below is in a custom style in which the label
 49 | is followed by a linebreak:
 50 | 
 51 | ::: statement-break
 52 | **The Principal Principle**. One's credence in $p$ conditional
 53 | on the hypothesis that the chance of $p$ is $x$ should be $x$.
 54 | :::
 55 | 
 56 | Acronyms can be specified too, at the beginning of the custom
 57 | label. When an acronym is present it is the basis of the automatic
 58 | id for crossreferencing, here @PP:
 59 | 
 60 | ::: statement
 61 | **(PP) The Principal Principle**. One's credence in $p$ conditional
 62 | on the hypothesis that the chance of $p$ is $x$ should be $x$.
 63 | :::
 64 | 
 65 | We may add info after the label. Either a simple citation or 
 66 | something in brackets:
 67 | 
 68 | ::: statement
 69 | **(PP) The Principal Principle**. (due to Lewis) One's credence in $p$ 
 70 | conditional on the hypothesis that the chance of 
 71 | $p$ is $x$ should be $x$.
 72 | :::
 73 | 
 74 | Note that automatic ID conflicts are avoided: the second PP statement
 75 | above is [identified as `PP-1`](#PP-1). 
 76 | 
 77 | Info can also be added without label. In LaTeX/PDF output the 
 78 | AMSThm package doesn't handle this well. 
 79 | 
 80 | ::: statement
 81 | (due to Lewis) One's credence in $p$ conditional on the hypothesis
 82 | that the chance of $p$ is $x$ should be $x$.
 83 | :::
 84 | 
 85 | Labels can contain UTF-8 chars and symbols. These are replaced by 
 86 | `_` and the letters are turned to lower-case:
 87 | 
 88 | ::: statement
 89 | **Poincaré's conjecture**. Every simply connected, closed, three-dimensional manifold is topologically equivalent to $S^3$.
 90 | :::
 91 | 
 92 | # Definition List syntax
 93 | 
 94 | The second part replicates the first, except that in markdown the 
 95 | statements are now entered with the DefinitionList syntax. Identifier
 96 | conflicts are avoided automatically or by using custom identifiers.
 97 | 
 98 | Statement
 99 | : This statement will be rendered as simple indented text. Curabitur dictum gravida mauris. Nam arcu libero, nonummy eget, consectetuer id, vulputate a, magna. 
100 | 
101 | :   * It contains two paragraphs
102 |     * and a list.
103 | 
104 | : Donec vehicula augue eu neque. Pellentesque habitant morbi tristique 
105 |     senectus et netus et malesuada fames ac turpis egestas. Mauris ut leo.
106 | 
107 | The statement below has a custom label. The label is automatically
108 | turned into an ID that can be used to 
109 | [reference it](#the-principal-principle-2). 
110 | 
111 | Statement __The Principal Principe__. 
112 | : One's credence in $p$ conditional on the hypothesis that the 
113 |     chance of $p$ is $x$ should be $x$.
114 | 
115 | The statement below is in a custom style in which the label
116 | is followed by a linebreak:
117 | 
118 | Statement-break __The Principal Principe__. 
119 | : One's credence in $p$ conditional on the hypothesis that the 
120 |     chance of $p$ is $x$ should be $x$.
121 | 
122 | Acronyms can be specified too, at the beginning of the custom
123 | label. This time we specify a ID individually, so we can refer to @myid.
124 | 
125 | Statement **(PP) The Principal Principle**. {#myid}
126 | :   One's credence in $p$ conditional
127 |     on the hypothesis that the chance of $p$ is $x$ should be $x$.
128 | 
129 | We may add info after the label. Either a simple citation or 
130 | something in brackets:
131 | 
132 | Statement __(PP) The Principal Principle__. (due to Lewis) 
133 | :   One's credence in $p$ conditional
134 |     on the hypothesis that the chance of $p$ is $x$ should be $x$.
135 | 
136 | Again that automatic ID conflicts are avoided: this link ([](#PP-2))
137 | will point to the one above. 
138 | 
139 | Info can also be added without label:
140 | 
141 | Statement. (due to Lewis) 
142 | :   One's credence in $p$ conditional on the hypothesis
143 |     that the chance of $p$ is $x$ should be $x$.
144 | 
145 | Labels can contain UTF-8 chars and symbols. These are replaced by 
146 | `_` and the letters are turned to lower-case:
147 | 
148 | Statement **Poincaré's conjecture**. 
149 | :   Every simply connected, closed, three-dimensional manifold is topologically 
150 |     equivalent to $S^3$.
151 | 
152 | 
153 | 
154 | 


--------------------------------------------------------------------------------
/tests/recursion_and_lists.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Recursions and lists in the statement filter
 3 | author: Julien Dutant
 4 | numbersections: true # LaTeX only, in HTML use -N or --number-sections
 5 | statement:
 6 |   defaults: 
 7 |   amsthm:
 8 |   aliases: 
 9 |   acronyms:
10 |   swap-numbers: false
11 |   define-in-header: yes
12 |   supply-header: yes
13 |   only-statement: false
14 | ---
15 | 
16 | # Mathematical theorems
17 | 
18 | ::: {.statement .example .unnumbered}
19 | 
20 | (a) The set of all prime divisors of $324$.
21 | (b) The set of all numbers divisible by 0.
22 | (c) The set of all continuous real-valued functions on the interval $[0,1]$.
23 | (d) The set of all ellipses with major axis $5$ and eccentricity $3$.
24 | (e) The set of all sets whose elements are natural numbers less than 20.
25 | 
26 | :::
27 | 
28 | ::: {.fact .unnumbered}
29 | 
30 | [@reference] another example
31 | 
32 | :::
33 | 
34 | ::: my-div
35 | 
36 | Recursion test. he two following statements are within list items within a Div element.
37 | 
38 | 1. :::::: statement
39 |    $X \subseteq Y$ if and only if every element of $X$ is an element of $Y$. 
40 |    ::::::
41 | 2. :::::: statement
42 |    __(NP) Named principle__. This is a named principle with an acronym.
43 |    ::::::
44 | 
45 | :::
46 | 
47 | Crossreference test. See ([](#NP)) or ([](#named-principle))! And citation
48 | syntax [@NP] or [@named-principle].
49 | 


--------------------------------------------------------------------------------
/tests/styles_based_on_styles.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | statement-styles:
 3 |     plain:
 4 |         space_after_head: 3em # try to redefine `plain`
 5 |     style1:
 6 |         label: Style1 Theorem
 7 |         margin-top: 12pt
 8 |         based-on: style2
 9 |     style2:
10 |         margin-top: 2em
11 |         margin-bottom: 2em
12 |         punctuation: ':'
13 |         based-on: remark
14 |     style5:
15 |         margin-top: 5em
16 |         based-on: style3 # circularity, this will generate an error but no crash
17 | statement:
18 |     styles:
19 |         style3:
20 |             margin-top: 3em
21 |             based-on: style4
22 |         style4:
23 |             margin-top: 4em
24 |             based-on: style5
25 | statement-kinds:
26 |     thm1:
27 |         style: style1
28 |         counter: thm1 # this will work, treated as 'self'
29 |     thm2:
30 |         style: style2
31 |         counter: thm1
32 |     thm3:
33 |         style: style3
34 |         counter: thm2 # this will throw an error, `thm2` has a shared counter
35 |     thm4:
36 |         style: style4
37 |     thm5:
38 |         style: style5
39 | ---
40 | 
41 | ::: theorem
42 | This is in `plain` style, redefined to have a large space after head.
43 | 
44 | :::
45 | 
46 | ::: thm1
47 | This is in `style1`. Not declared as based on anything, so it is
48 | assumed to be based on `plain`. 
49 | :::
50 | 
51 | ::: thm2
52 | This is in `style2`. It is based on `remark`. No label has been provided. We've
53 | changed the punctuation to ':'.
54 | :::
55 | 
56 | ::: thm3
57 | This is in `style3`.
58 | :::
59 | 
60 | ::: thm4
61 | This is in `style4`.
62 | :::
63 | 
64 | ::: thm5
65 | This is in `style5`.
66 | :::
67 | 
68 | 
69 | 
70 | 


--------------------------------------------------------------------------------
/tests/styles_customize.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | statement-styles:
 3 |     theorem:
 4 |         body-font: normal
 5 |         head-font: emph
 6 |     mybold:
 7 |         body-font: bold
 8 |         head-font: bold italics
 9 | statement-kinds:
10 |     mybold: 
11 |         style: mybold
12 |         label: Bold Claim
13 |         counter: theorem
14 | ---
15 | 
16 | ::: theorem
17 | Something to say.
18 | :::
19 | 
20 | ::: definition
21 | Something to say.
22 | :::
23 | 
24 | ::: mybold
25 | Something loud to say.
26 | :::
27 | 


--------------------------------------------------------------------------------
/tests/syntax_definition_lists.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: Definition list synatx with the statement filter
 3 | ---
 4 | 
 5 | # Examples
 6 | 
 7 | Theorem.
 8 | : A simple theorem with definition label `Theorem`.
 9 | 
10 | lem
11 | : A simple theorem with a short prefix label `lem`.
12 | : This definition list has several definitions.
13 | 
14 |     Some of them have multiple blocks.
15 | 
16 | :   All are included in the theorem's content.
17 | 
18 | Theorem (some info).
19 | : This statement has only info.
20 | 
21 | Theorem some stuff that's not *bracketed*
22 | : When the theorem name is followed by some content that's
23 |     not marked out as custom label or info (no brackets),
24 |     we insert it in the statement's content.
25 | 
26 | Term1
27 | : We can insert genuine Definition Lists in the middle.
28 | : Here `Term1` and `Term2` are defined.
29 | 
30 | Term2
31 | : In the source they are part of a DefinitionList that
32 |     includes the theorems above and below; the filter
33 |     splits it. 
34 | 
35 | Theorem (some info).
36 | : We can place a dot after the info.
37 | 
38 | Theorem. (some info)
39 | : Or before.
40 | 
41 | Theorem (some info) \label{mytheorem}
42 | : This label receives an identifier with the LaTeX
43 |     `\label{...}` command.
44 | 
45 | Theorem (some info) {#another}
46 | : This label receives an identifier with markdown
47 |     syntax `{#another}``.
48 | 
49 | Some crossreferences: @mytheorem refers to the one identified
50 | with `\label{...}` and @another to the one identified with
51 | `{#...}`. @KL use an acronym to refer to the one below:
52 | 
53 | Lemma **(KL) Klein's lemma** (source)
54 | : Perhaps we could Strong elements to create custom labels?
55 | 
56 | # Recursion test
57 | 
58 | Term3
59 | :   This is a standard definition. Its contents are processed
60 |     recursively in case they contain further definitions.
61 | :   Here we include a Div-style statement:
62 | 
63 |     ::: theorem
64 |     My embedded theorem
65 |     :::
66 | 
67 |     It should be rendered as a theorem.
68 | 
69 | :   Pandoc doesn't create DefinitionLists within DefinitionLists
70 |     so we don't test that.
71 | :   But we can test Div-style statements within bullet lists
72 |     within definitions.
73 | 
74 |     - list item
75 |     - list item that contains a lemma
76 |     
77 |       ::: lemma
78 |       My embedded lemma
79 |       :::
80 | 
81 |     - list item
82 | 
83 | : This is the last definition of Term3.
84 | 
85 | The definition of Term 3 is complete.


--------------------------------------------------------------------------------
/tests/syntax_fenced_div.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: Label and info syntax tests
  3 | author: Julien Dutant
  4 | numbersections: true # LaTeX only, in HTML use -N or --number-sections
  5 | references:
  6 | - type: article-journal
  7 |   id: thatone
  8 |   author:
  9 |   - family: Dummy
 10 |     given: D.
 11 |   issued:
 12 |     date-parts:
 13 |     - - 1900
 14 |       - 1
 15 |       - 1
 16 |   title: 'Dummy reference'
 17 |   container-title: Journal
 18 |   volume: 1
 19 |   issue: 1
 20 |   page: 1-10
 21 | - type: article-journal
 22 |   id: theother
 23 |   author:
 24 |   - family: Otherdummy
 25 |     given: A.N.
 26 |   issued:
 27 |     date-parts:
 28 |     - - 1900
 29 |       - 1
 30 |       - 1
 31 |   title: 'Dummy reference'
 32 |   container-title: Journal
 33 |   volume: 1
 34 |   issue: 1
 35 |   page: 1-10
 36 | ---
 37 | 
 38 | ::: thm
 39 | 
 40 | * Starts with
 41 | * A list
 42 | 
 43 | This statement has no label or info.
 44 | :::
 45 | 
 46 | ::: thm
 47 | 1. Starts with
 48 | 2. a list
 49 | 
 50 | (some info) This statement has only info.
 51 | :::
 52 | 
 53 | ::: thm
 54 | (some info). This statement has only info, dot is allowed too.
 55 | :::
 56 | 
 57 | ::: thm
 58 | @thatone [@theother] This statement has a couple of citations as info.
 59 | In JATS, citeproc fails to process the info's embedded citations.
 60 | :::
 61 | 
 62 | ::: thm
 63 | @thatone [@theother]. This works with a point too.
 64 | :::
 65 | 
 66 | ::: thm
 67 | **(some info)** Info can be placed within Strong emphasis too.
 68 | :::
 69 | 
 70 | ::: thm
 71 | **@thatone.** And a dot can be placed within the Strong emphasis.
 72 | :::
 73 | 
 74 | ::: thm
 75 | **(some info)**. Or just outside.
 76 | :::
 77 | 
 78 | ::: thm
 79 | **Klein's lemma**. This statement has a custom label.
 80 | :::
 81 | 
 82 | ::: thm
 83 | **(KL) Klein's lemma**. This statement has a custom label and acronym.
 84 | :::
 85 | 
 86 | The acronym can be used to crossrefer the statement @KL.
 87 | 
 88 | ::: thm
 89 | **(KL) Klein's lemma.** The filter doesn't care whether there is a dot
 90 | after or before the Strong emphasis label.
 91 | :::
 92 | 
 93 | ::: thm
 94 | **(KL) Klein's lemma** Or no dot at all.
 95 | :::
 96 | 
 97 | ::: thm
 98 | **(KL) Klein's lemma**Even if there's no space - ugly but we won't chase it.
 99 | :::
100 | 
101 | ::: thm
102 | **(PP) Principal Principle (Lewis).** Info can be placed with the Strong 
103 | emphasis custom label.
104 | :::
105 | 
106 | ::: thm
107 | **(PP) Principal Principle @thatone [@theother].** Here the info is
108 | a Cite element within the label.
109 | :::
110 | 
111 | ::: thm
112 | **(PP) Principal Principle ** @thatone [@theother] Here the info is
113 | a Cite element without the label.
114 | :::
115 | 
116 | ::: thm
117 | **(PP) (Lewis).** Acronym plus info without custom label should fail.
118 | `**(PP) (Lewis).**` is treated is part of the theorem.
119 | :::
120 | 
121 | # References
122 | 


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