data/pandoc.lua · typeable/pandoc

git.iko.soy/typeable/pandoc

on 2.2.3 help sign in

typeable/pandoc/data/pandoc.lua

945 lines 28 kB history raw

1--[[

2pandoc.lua

6Permission to use, copy, modify, and/or distribute this software for any purpose

7with or without fee is hereby granted, provided that the above copyright notice

8and this permission notice appear in all copies.

10THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH

11REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

12FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,

13INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

14OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

15TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF

16THIS SOFTWARE.

17]]

19---

20-- Lua functions for pandoc scripts.

21--

22-- @author Albert Krewinkel

24-- @license MIT

25local M = {}

27local List = require 'pandoc.List'

29------------------------------------------------------------------------

30-- Accessor objects

31--

32-- Create metatables which allow to access numerical indices via accessor

33-- methods.

34-- @section

35-- @local

37--- Create a new indexing function.

38-- @param template function template

39-- @param indices list of indices, starting with the most deeply nested

40-- @return newly created function

41-- @local

42function make_indexing_function(template, indices)

43 local loadstring = loadstring or load

44 local bracketed = {}

45 for i = 1, #indices do

46 bracketed[i] = string.format('[%d]', indices[#indices - i + 1])

47 end

48 local fnstr = string.format('return ' .. template, table.concat(bracketed))

49 return assert(loadstring(fnstr))()

50end

52--- Create accessor functions using a function template.

53-- @param fn_template function template in which '%s' is replacd with indices

54-- @param accessors list of accessors

55-- @return mapping from accessor names to accessor functions

56-- @local

57local function create_accessor_functions (fn_template, accessors)

58 local res = {}

59 function add_accessors(acc, ...)

60 if type(acc) == 'string' then

61 res[acc] = make_indexing_function(fn_template, {...})

62 elseif type(acc) == 'table' and #acc == 0 and next(acc) then

63 local name, substructure = next(acc)

64 res[name] = make_indexing_function(fn_template, {...})

65 add_accessors(substructure, ...)

66 else

67 for i = 1, #(acc or {}) do

68 add_accessors(acc[i], i, ...)

69 end

70 end

71 end

72 add_accessors(accessors)

73 return res

74end

76--- Create a new table which allows to access numerical indices via accessor

77-- functions.

78-- @local

79local function create_accessor_behavior (tag, accessors)

80 local behavior = {tag = tag}

81 behavior.getters = create_accessor_functions(

82 'function (x) return x.c%s end',

83 accessors

84 )

85 behavior.setters = create_accessor_functions(

86 'function (x, v) x.c%s = v end',

87 accessors

88 )

89 behavior.__index = function(t, k)

90 if getmetatable(t).getters[k] then

91 return getmetatable(t).getters[k](t)

92 elseif k == "t" then

93 return getmetatable(t)["tag"]

94 else

95 return getmetatable(t)[k]

96 end

97 end

98 behavior.__newindex = function(t, k, v)

99 if getmetatable(t).setters[k] then

100 getmetatable(t).setters[k](t, v)

101 else

102 rawset(t, k, v)

103 end

104 end

105 return behavior

106end

107

108

109------------------------------------------------------------------------

110-- The base class for types

111-- @type Type

112-- @local

113local Type = {}

114Type.name = 'Type'

115Type.__index = Type

116Type.behavior = {

117 __type = Type,

118 new = function (obj)

119 obj = obj or {}

120 setmetatable(obj, self)

121 return obj

122 end

123}

124Type.behavior.__index = Type.behavior

125

126--- Set a new behavior for the type, inheriting that of the parent type if none

127--- is specified explicitly

128-- @param behavior the behavior object for this type.

129-- @local

130function Type:set_behavior (behavior)

131 behavior = behavior or {}

132 behavior.__index = rawget(behavior, '__index') or behavior

133 behavior.__type = self

134 if not getmetatable(behavior) and getmetatable(self) then

135 setmetatable(behavior, getmetatable(self).behavior)

136 end

137 self.behavior = behavior

138end

139

140--- Create a new subtype, using the given table as base.

141-- @param name name of the new type

142-- @param[opt] behavior behavioral object for the new type.

143-- @return a new type

144-- @local

145function Type:make_subtype(name, behavior)

146 local newtype = setmetatable({}, self)

147 newtype.name = name

148 newtype.__index = newtype

149 newtype:set_behavior(behavior)

150 return newtype

151end

152

153

154------------------------------------------------------------------------

155-- The base class for pandoc's AST elements.

156-- @type AstElement

157-- @local

158local AstElement = Type:make_subtype 'AstElement'

159AstElement.__call = function(t, ...)

160 local success, ret = pcall(t.new, t, ...)

161 if success then

162 return setmetatable(ret, t.behavior)

163 else

164 error(string.format('Constructor for %s failed: %s\n', t.name, ret))

165 end

166end

167

168--- Make a new subtype which constructs a new value when called.

169-- @local

170function AstElement:make_subtype(...)

171 local newtype = Type.make_subtype(self, ...)

172 newtype.__call = self.__call

173 return newtype

174end

175

176--- Create a new constructor

177-- @local

178-- @param tag Tag used to identify the constructor

179-- @param fn Function to be called when constructing a new element

180-- @param accessors names to use as accessors for numerical fields

181-- @return function that constructs a new element

182function AstElement:create_constructor(tag, fn, accessors)

183 local constr = self:make_subtype(tag, create_accessor_behavior(tag, accessors))

184 function constr:new(...)

185 return setmetatable(fn(...), self.behavior)

186 end

187 self.constructor = self.constructor or {}

188 self.constructor[tag] = constr

189 return constr

190end

191

192--- Convert AstElement input into a list if necessary.

193-- @local

194local function ensureList (x)

195 if x.tag then

196 -- Lists are not tagged, but all elements are

197 return List:new{x}

198 else

199 return List:new(x)

200 end

201end

202

203--- Ensure a given object is an Inline element, or convert it into one.

204-- @local

205local function ensureInlineList (x)

206 if type(x) == 'string' then

207 return List:new{M.Str(x)}

208 else

209 return ensureList(x)

210 end

211end

212

213------------------------------------------------------------------------

214--- Pandoc Document

215-- @section document

216

217--- A complete pandoc document

218-- @function Pandoc

219-- @tparam {Block,...} blocks document content

220-- @tparam[opt] Meta meta document meta data

221M.Pandoc = AstElement:make_subtype'Pandoc'

222function M.Pandoc:new (blocks, meta)

223 return {

224 blocks = ensureList(blocks),

225 meta = meta or {},

226 }

227end

228

229-- DEPRECATED synonym:

230M.Doc = M.Pandoc

231

232------------------------------------------------------------------------

233-- Meta

234-- @section Meta

235

236--- Create a new Meta object. It sets the metatable of the given table to

237--- `Meta`.

238-- @function Meta

239-- @tparam meta table table containing document meta information

240M.Meta = AstElement:make_subtype'Meta'

241function M.Meta:new (meta) return meta end

242

243

244------------------------------------------------------------------------

245-- MetaValue

246-- @section MetaValue

247M.MetaValue = AstElement:make_subtype('MetaValue')

248

249--- Meta blocks

250-- @function MetaBlocks

251-- @tparam {Block,...} blocks blocks

252M.MetaBlocks = M.MetaValue:create_constructor(

253 'MetaBlocks',

254 function (content) return ensureList(content) end

255)

256

257--- Meta inlines

258-- @function MetaInlines

259-- @tparam {Inline,...} inlines inlines

260M.MetaInlines = M.MetaValue:create_constructor(

261 'MetaInlines',

262 function (content) return ensureInlineList(content) end

263)

264

265--- Meta list

266-- @function MetaList

267-- @tparam {MetaValue,...} meta_values list of meta values

268M.MetaList = M.MetaValue:create_constructor(

269 'MetaList',

270 function (content) return ensureList(content) end

271)

272

273--- Meta map

274-- @function MetaMap

275-- @tparam table key_value_map a string-indexed map of meta values

276M.MetaMap = M.MetaValue:create_constructor(

277 "MetaMap",

278 function (mm) return mm end

279)

280

281--- Creates string to be used in meta data.

282-- Does nothing, lua strings are meta strings.

283-- @function MetaString

284-- @tparam string str string value

285function M.MetaString(str)

286 return str

287end

288

289--- Creates boolean to be used in meta data.

290-- Does nothing, lua booleans are meta booleans.

291-- @function MetaBool

292-- @tparam boolean bool boolean value

293function M.MetaBool(bool)

294 return bool

295end

296

297------------------------------------------------------------------------

298-- Blocks

299-- @section Block

300

301--- Block elements

302M.Block = AstElement:make_subtype'Block'

303

304--- Creates a block quote element

305-- @function BlockQuote

306-- @tparam {Block,...} content block content

307-- @treturn Block block quote element

308M.BlockQuote = M.Block:create_constructor(

309 "BlockQuote",

310 function(content) return {c = ensureList(content)} end,

311 "content"

312)

313

314--- Creates a bullet (i.e. unordered) list.

315-- @function BulletList

316-- @tparam {{Block,...},...} content list of items

317-- @treturn Block bullet list element

318M.BulletList = M.Block:create_constructor(

319 "BulletList",

320 function(content) return {c = ensureList(content)} end,

321 "content"

322)

323

324--- Creates a code block element

325-- @function CodeBlock

326-- @tparam string text code string

327-- @tparam[opt] Attr attr element attributes

328-- @treturn Block code block element

329M.CodeBlock = M.Block:create_constructor(

330 "CodeBlock",

331 function(text, attr) return {c = {attr or M.Attr(), text}} end,

332 {{attr = {"identifier", "classes", "attributes"}}, "text"}

333)

334

335--- Creates a definition list, containing terms and their explanation.

336-- @function DefinitionList

337-- @tparam {{{Inline,...},{Block,...}},...} content list of items

338-- @treturn Block definition list element

339M.DefinitionList = M.Block:create_constructor(

340 "DefinitionList",

341 function(content) return {c = ensureList(content)} end,

342 "content"

343)

344

345--- Creates a div element

346-- @function Div

347-- @tparam {Block,...} content block content

348-- @tparam[opt] Attr attr element attributes

349-- @treturn Block div element

350M.Div = M.Block:create_constructor(

351 "Div",

352 function(content, attr)

353 return {c = {attr or M.Attr(), ensureList(content)}}

354 end,

355 {{attr = {"identifier", "classes", "attributes"}}, "content"}

356)

357

358--- Creates a header element.

359-- @function Header

360-- @tparam int level header level

361-- @tparam {Inline,...} content inline content

362-- @tparam[opt] Attr attr element attributes

363-- @treturn Block header element

364M.Header = M.Block:create_constructor(

365 "Header",

366 function(level, content, attr)

367 return {c = {level, attr or M.Attr(), ensureInlineList(content)}}

368 end,

369 {"level", {attr = {"identifier", "classes", "attributes"}}, "content"}

370)

371

372--- Creates a horizontal rule.

373-- @function HorizontalRule

374-- @treturn Block horizontal rule

375M.HorizontalRule = M.Block:create_constructor(

376 "HorizontalRule",

377 function() return {} end

378)

379

380--- Creates a line block element.

381-- @function LineBlock

382-- @tparam {{Inline,...},...} content inline content

383-- @treturn Block line block element

384M.LineBlock = M.Block:create_constructor(

385 "LineBlock",

386 function(content) return {c = ensureList(content)} end,

387 "content"

388)

389

390--- Creates a null element.

391-- @function Null

392-- @treturn Block null element

393M.Null = M.Block:create_constructor(

394 "Null",

395 function() return {} end

396)

397

398--- Creates an ordered list.

399-- @function OrderedList

400-- @tparam {{Block,...},...} items list items

401-- @param[opt] listAttributes list parameters

402-- @treturn Block ordered list element

403M.OrderedList = M.Block:create_constructor(

404 "OrderedList",

405 function(items, listAttributes)

406 listAttributes = listAttributes or {1, M.DefaultStyle, M.DefaultDelim}

407 return {c = {listAttributes, ensureList(items)}}

408 end,

409 {{listAttributes = {"start", "style", "delimiter"}}, "content"}

410)

411

412--- Creates a para element.

413-- @function Para

414-- @tparam {Inline,...} content inline content

415-- @treturn Block paragraph element

416M.Para = M.Block:create_constructor(

417 "Para",

418 function(content) return {c = ensureInlineList(content)} end,

419 "content"

420)

421

422--- Creates a plain element.

423-- @function Plain

424-- @tparam {Inline,...} content inline content

425-- @treturn Block plain element

426M.Plain = M.Block:create_constructor(

427 "Plain",

428 function(content) return {c = ensureInlineList(content)} end,

429 "content"

430)

431

432--- Creates a raw content block of the specified format.

433-- @function RawBlock

434-- @tparam string format format of content

435-- @tparam string text string content

436-- @treturn Block raw block element

437M.RawBlock = M.Block:create_constructor(

438 "RawBlock",

439 function(format, text) return {c = {format, text}} end,

440 {"format", "text"}

441)

442

443--- Creates a table element.

444-- @function Table

445-- @tparam {Inline,...} caption table caption

446-- @tparam {AlignDefault|AlignLeft|AlignRight|AlignCenter,...} aligns alignments

447-- @tparam {int,...} widths column widths

448-- @tparam {Block,...} headers header row

449-- @tparam {{Block,...}} rows table rows

450-- @treturn Block table element

451M.Table = M.Block:create_constructor(

452 "Table",

453 function(caption, aligns, widths, headers, rows)

454 return {

455 c = {

456 ensureInlineList(caption),

457 List:new(aligns),

458 List:new(widths),

459 List:new(headers),

460 List:new(rows)

461 }

462 }

463 end,

464 {"caption", "aligns", "widths", "headers", "rows"}

465)

466

467

468------------------------------------------------------------------------

469-- Inline

470-- @section Inline

471

472--- Inline element class

473M.Inline = AstElement:make_subtype'Inline'

474

475--- Creates a Cite inline element

476-- @function Cite

477-- @tparam {Inline,...} content List of inlines

478-- @tparam {Citation,...} citations List of citations

479-- @treturn Inline citations element

480M.Cite = M.Inline:create_constructor(

481 "Cite",

482 function(content, citations)

483 return {c = {ensureList(citations), ensureInlineList(content)}}

484 end,

485 {"citations", "content"}

486)

487

488--- Creates a Code inline element

489-- @function Code

490-- @tparam string text brief image description

491-- @tparam[opt] Attr attr additional attributes

492-- @treturn Inline code element

493M.Code = M.Inline:create_constructor(

494 "Code",

495 function(text, attr) return {c = {attr or M.Attr(), text}} end,

496 {{attr = {"identifier", "classes", "attributes"}}, "text"}

497)

498

499--- Creates an inline element representing emphasised text.

500-- @function Emph

501-- @tparam {Inline,..} content inline content

502-- @treturn Inline emphasis element

503M.Emph = M.Inline:create_constructor(

504 "Emph",

505 function(content) return {c = ensureInlineList(content)} end,

506 "content"

507)

508

509--- Creates a Image inline element

510-- @function Image

511-- @tparam {Inline,..} caption text used to describe the image

512-- @tparam string src path to the image file

513-- @tparam[opt] string title brief image description

514-- @tparam[opt] Attr attr additional attributes

515-- @treturn Inline image element

516M.Image = M.Inline:create_constructor(

517 "Image",

518 function(caption, src, title, attr)

519 title = title or ""

520 attr = attr or M.Attr()

521 return {c = {attr, ensureInlineList(caption), {src, title}}}

522 end,

523 {{attr = {"identifier", "classes", "attributes"}}, "caption", {"src", "title"}}

524)

525

526--- Create a LineBreak inline element

527-- @function LineBreak

528-- @treturn Inline linebreak element

529M.LineBreak = M.Inline:create_constructor(

530 "LineBreak",

531 function() return {} end

532)

533

534--- Creates a link inline element, usually a hyperlink.

535-- @function Link

536-- @tparam {Inline,..} content text for this link

537-- @tparam string target the link target

538-- @tparam[opt] string title brief link description

539-- @tparam[opt] Attr attr additional attributes

540-- @treturn Inline image element

541M.Link = M.Inline:create_constructor(

542 "Link",

543 function(content, target, title, attr)

544 title = title or ""

545 attr = attr or M.Attr()

546 return {c = {attr, ensureInlineList(content), {target, title}}}

547 end,

548 {{attr = {"identifier", "classes", "attributes"}}, "content", {"target", "title"}}

549)

550

551--- Creates a Math element, either inline or displayed.

552-- @function Math

553-- @tparam "InlineMath"|"DisplayMath" mathtype rendering specifier

554-- @tparam string text Math content

555-- @treturn Inline Math element

556M.Math = M.Inline:create_constructor(

557 "Math",

558 function(mathtype, text)

559 return {c = {mathtype, text}}

560 end,

561 {"mathtype", "text"}

562)

563--- Creates a DisplayMath element (DEPRECATED).

564-- @function DisplayMath

565-- @tparam string text Math content

566-- @treturn Inline Math element

567M.DisplayMath = M.Inline:create_constructor(

568 "DisplayMath",

569 function(text) return M.Math("DisplayMath", text) end,

570 {"mathtype", "text"}

571)

572--- Creates an InlineMath inline element (DEPRECATED).

573-- @function InlineMath

574-- @tparam string text Math content

575-- @treturn Inline Math element

576M.InlineMath = M.Inline:create_constructor(

577 "InlineMath",

578 function(text) return M.Math("InlineMath", text) end,

579 {"mathtype", "text"}

580)

581

582--- Creates a Note inline element

583-- @function Note

584-- @tparam {Block,...} content footnote block content

585M.Note = M.Inline:create_constructor(

586 "Note",

587 function(content) return {c = ensureList(content)} end,

588 "content"

589)

590

591--- Creates a Quoted inline element given the quote type and quoted content.

592-- @function Quoted

593-- @tparam "DoubleQuote"|"SingleQuote" quotetype type of quotes to be used

594-- @tparam {Inline,..} content inline content

595-- @treturn Inline quoted element

596M.Quoted = M.Inline:create_constructor(

597 "Quoted",

598 function(quotetype, content) return {c = {quotetype, ensureInlineList(content)}} end,

599 {"quotetype", "content"}

600)

601--- Creates a single-quoted inline element (DEPRECATED).

602-- @function SingleQuoted

603-- @tparam {Inline,..} content inline content

604-- @treturn Inline quoted element

605-- @see Quoted

606M.SingleQuoted = M.Inline:create_constructor(

607 "SingleQuoted",

608 function(content) return M.Quoted(M.SingleQuote, content) end,

609 {"quotetype", "content"}

610)

611--- Creates a single-quoted inline element (DEPRECATED).

612-- @function DoubleQuoted

613-- @tparam {Inline,..} content inline content

614-- @treturn Inline quoted element

615-- @see Quoted

616M.DoubleQuoted = M.Inline:create_constructor(

617 "DoubleQuoted",

618 function(content) return M.Quoted("DoubleQuote", content) end,

619 {"quotetype", "content"}

620)

621

622--- Creates a RawInline inline element

623-- @function RawInline

624-- @tparam string format format of the contents

625-- @tparam string text string content

626-- @treturn Inline raw inline element

627M.RawInline = M.Inline:create_constructor(

628 "RawInline",

629 function(format, text) return {c = {format, text}} end,

630 {"format", "text"}

631)

632

633--- Creates text rendered in small caps

634-- @function SmallCaps

635-- @tparam {Inline,..} content inline content

636-- @treturn Inline smallcaps element

637M.SmallCaps = M.Inline:create_constructor(

638 "SmallCaps",

639 function(content) return {c = ensureInlineList(content)} end,

640 "content"

641)

642

643--- Creates a SoftBreak inline element.

644-- @function SoftBreak

645-- @treturn Inline softbreak element

646M.SoftBreak = M.Inline:create_constructor(

647 "SoftBreak",

648 function() return {} end

649)

650

651--- Create a Space inline element

652-- @function Space

653-- @treturn Inline space element

654M.Space = M.Inline:create_constructor(

655 "Space",

656 function() return {} end

657)

658

659--- Creates a Span inline element

660-- @function Span

661-- @tparam {Inline,..} content inline content

662-- @tparam[opt] Attr attr additional attributes

663-- @treturn Inline span element

664M.Span = M.Inline:create_constructor(

665 "Span",

666 function(content, attr)

667 return {c = {attr or M.Attr(), ensureInlineList(content)}}

668 end,

669 {{attr = {"identifier", "classes", "attributes"}}, "content"}

670)

671

672--- Creates a Str inline element

673-- @function Str

674-- @tparam string text content

675-- @treturn Inline string element

676M.Str = M.Inline:create_constructor(

677 "Str",

678 function(text) return {c = text} end,

679 "text"

680)

681

682--- Creates text which is striked out.

683-- @function Strikeout

684-- @tparam {Inline,..} content inline content

685-- @treturn Inline strikeout element

686M.Strikeout = M.Inline:create_constructor(

687 "Strikeout",

688 function(content) return {c = ensureInlineList(content)} end,

689 "content"

690)

691

692--- Creates a Strong element, whose text is usually displayed in a bold font.

693-- @function Strong

694-- @tparam {Inline,..} content inline content

695-- @treturn Inline strong element

696M.Strong = M.Inline:create_constructor(

697 "Strong",

698 function(content) return {c = ensureInlineList(content)} end,

699 "content"

700)

701

702--- Creates a Subscript inline element

703-- @function Subscript

704-- @tparam {Inline,..} content inline content

705-- @treturn Inline subscript element

706M.Subscript = M.Inline:create_constructor(

707 "Subscript",

708 function(content) return {c = ensureInlineList(content)} end,

709 "content"

710)

711

712--- Creates a Superscript inline element

713-- @function Superscript

714-- @tparam {Inline,..} content inline content

715-- @treturn Inline strong element

716M.Superscript = M.Inline:create_constructor(

717 "Superscript",

718 function(content) return {c = ensureInlineList(content)} end,

719 "content"

720)

721

722

723------------------------------------------------------------------------

724-- Element components

725-- @section components

726

727--- Check if the first element of a pair matches the given value.

728-- @param x key value to be checked

729-- @return function returning true iff first element of its argument matches x

730-- @local

731local function assoc_key_equals (x)

732 return function (y) return y[1] == x end

733end

734

735--- Lookup a value in an associative list

736-- @function lookup

737-- @local

738-- @tparam {{key, value},...} alist associative list

739-- @param key key for which the associated value is to be looked up

740local function lookup(alist, key)

741 return (List.find_if(alist, assoc_key_equals(key)) or {})[2]

742end

743

744--- Return an iterator which returns key-value pairs of an associative list.

745-- @function apairs

746-- @local

747-- @tparam {{key, value},...} alist associative list

748local apairs = function (alist)

749 local i = 1

750 local cur

751 function nxt ()

752 cur = rawget(alist, i)

753 if cur then

754 i = i + 1

755 return cur[1], cur[2]

756 end

757 return nil

758 end

759 return nxt, nil, nil

760end

761

762--- AttributeList, a metatable to allow table-like access to attribute lists

763-- represented by associative lists.

764-- @local

765local AttributeList = {

766 __index = function (t, k)

767 if type(k) == "number" then

768 return rawget(t, k)

769 else

770 return lookup(t, k)

771 end

772 end,

773

774 __newindex = function (t, k, v)

775 local cur, idx = List.find_if(t, assoc_key_equals(k))

776 if v == nil then

777 table.remove(t, idx)

778 elseif cur then

779 cur[2] = v

780 elseif type(k) == "number" then

781 rawset(t, k, v)

782 else

783 rawset(t, #t + 1, {k, v})

784 end

785 end,

786

787 __pairs = apairs

788}

789

790--- Convert a table to an associative list. The order of key-value pairs in the

791-- alist is undefined. The table should either contain no numeric keys or

792-- already be an associative list.

793-- @local

794-- @tparam table tbl associative list or table without numeric keys.

795-- @treturn table associative list

796local to_alist = function (tbl)

797 if #tbl ~= 0 or next(tbl) == nil then

798 -- probably already an alist

799 return tbl

800 end

801 local alist = {}

802 local i = 1

803 for k, v in pairs(tbl) do

804 alist[i] = {k, v}

805 i = i + 1

806 end

807 return alist

808end

809

810-- Attr

811

812--- Create a new set of attributes (Attr).

813-- @function Attr

814-- @tparam[opt] string identifier element identifier

815-- @tparam[opt] {string,...} classes element classes

816-- @tparam[opt] table attributes table containing string keys and values

817-- @return element attributes

818M.Attr = AstElement:make_subtype'Attr'

819function M.Attr:new (identifier, classes, attributes)

820 identifier = identifier or ''

821 classes = ensureList(classes or {})

822 attributes = setmetatable(to_alist(attributes or {}), AttributeList)

823 return {identifier, classes, attributes}

824end

825M.Attr.behavior._field_names = {identifier = 1, classes = 2, attributes = 3}

826M.Attr.behavior.__index = function(t, k)

827 return rawget(t, getmetatable(t)._field_names[k]) or

828 getmetatable(t)[k]

829end

830M.Attr.behavior.__newindex = function(t, k, v)

831 if getmetatable(t)._field_names[k] then

832 rawset(t, getmetatable(t)._field_names[k], v)

833 else

834 rawset(t, k, v)

835 end

836end

837

838-- Citation

839M.Citation = AstElement:make_subtype'Citation'

840

841--- Creates a single citation.

842-- @function Citation

843-- @tparam string id citation identifier (like a bibtex key)

844-- @tparam AuthorInText|SuppressAuthor|NormalCitation mode citation mode

845-- @tparam[opt] {Inline,...} prefix citation prefix

846-- @tparam[opt] {Inline,...} suffix citation suffix

847-- @tparam[opt] int note_num note number

848-- @tparam[opt] int hash hash number

849function M.Citation:new (id, mode, prefix, suffix, note_num, hash)

850 return {

851 id = id,

852 mode = mode,

853 prefix = ensureList(prefix or {}),

854 suffix = ensureList(suffix or {}),

855 note_num = note_num or 0,

856 hash = hash or 0,

857 }

858end

859

860

861------------------------------------------------------------------------

862-- Constants

863-- @section constants

864

865--- Author name is mentioned in the text.

866-- @see Citation

867-- @see Cite

868M.AuthorInText = "AuthorInText"

869

870--- Author name is suppressed.

871-- @see Citation

872-- @see Cite

873M.SuppressAuthor = "SuppressAuthor"

874

875--- Default citation style is used.

876-- @see Citation

877-- @see Cite

878M.NormalCitation = "NormalCitation"

879

880--- Table cells aligned left.

881-- @see Table

882M.AlignLeft = "AlignLeft"

883

884--- Table cells right-aligned.

885-- @see Table

886M.AlignRight = "AlignRight"

887

888--- Table cell content is centered.

889-- @see Table

890M.AlignCenter = "AlignCenter"

891

892--- Table cells are alignment is unaltered.

893-- @see Table

894M.AlignDefault = "AlignDefault"

895

896--- Default list number delimiters are used.

897-- @see OrderedList

898M.DefaultDelim = "DefaultDelim"

899

900--- List numbers are delimited by a period.

901-- @see OrderedList

902M.Period = "Period"

903

904--- List numbers are delimited by a single parenthesis.

905-- @see OrderedList

906M.OneParen = "OneParen"

907

908--- List numbers are delimited by a double parentheses.

909-- @see OrderedList

910M.TwoParens = "TwoParens"

911

912--- List are numbered in the default style

913-- @see OrderedList

914M.DefaultStyle = "DefaultStyle"

915

916--- List items are numbered as examples.

917-- @see OrderedList

918M.Example = "Example"

919

920--- List are numbered using decimal integers.

921-- @see OrderedList

922M.Decimal = "Decimal"

923

924--- List are numbered using lower-case roman numerals.

925-- @see OrderedList

926M.LowerRoman = "LowerRoman"

927

928--- List are numbered using upper-case roman numerals

929-- @see OrderedList

930M.UpperRoman = "UpperRoman"

931

932--- List are numbered using lower-case alphabetic characters.

933-- @see OrderedList

934M.LowerAlpha = "LowerAlpha"

935

936--- List are numbered using upper-case alphabetic characters.

937-- @see OrderedList

938M.UpperAlpha = "UpperAlpha"

939

940------------------------------------------------------------------------

941-- Functions which have moved to different modules

942local utils = require 'pandoc.utils'

943M.sha1 = utils.sha1

944

945return M