⟨1 Start elements⟩ ≡

start = PretextRoot | DocInfo | Part | Chapter | Section | Subsection | Subsubsection | Printout | Slideshow | Paragraphs | ReadingQuestions | Exercises | Subexercises |  Solutions | BookFrontMatter | ArticleFrontMatter | BookBackMatter | ArticleBackMatter | Preface | Acknowledgement | ArticleAppendix | BookAppendix | IndexDivision | References | Glossary | Figure | WebWork

⟨2 Gross structure⟩ ≡

PretextRoot =
    element pretext {
        XMLLang?,
        DocInfo?,
        (Book | Article | Letter | Memorandum | Slideshow)
    }

⟨3 Document types⟩ ≡

Article =
    element article {
        MetaDataLinedSubtitle,
        ArticleFrontMatter?,
        (
            (
                Objectives?,
                (BlockDivision | Paragraphs)+,
                (Worksheet? & Handout? & ReadingQuestions? & Exercises? &
                 Solutions? & References? & Glossary?),
                Outcomes?
            )
        |
            (
                (Objectives? & IntroductionCompanion?),
                (Section | Printout),
                (Section | Printout | ReadingQuestions | Exercises |
                 Solutions | References | Glossary)*,
                (Outcomes? & ConclusionCompanion?),
                ArticleBackMatter?
            )
        )
    }
Book =
    ## Here is what a book looks like.
    element book {
        MetaDataLinedSubtitle,
        BookFrontMatter?,
        (Part+ | Chapter+ | Printout+),
        BookBackMatter?
    }
Letter =
    element letter {empty}
Memorandum =
    element memo {empty}

⟨4 Slideshows⟩ ≡

Slideshow =
    element slideshow {
        MetaDataLinedSubtitle,
        ArticleFrontMatter?,
        (SlideshowSection+ | Slide+)
    }
# a slideshow's "section" organizes slides, nothing more
SlideshowSection =
    element section {
        MetaDataAltTitle,
        Slide+
    }
Slide =
    element slide {
        # vertical placement of this slide's content,
        # overriding the document-wide default
        attribute valign {"top" | "middle" | "bottom"}?,
        MetaDataAltTitle,
        (BlockDivision | List | Subslide)+
    }
# a group of material appearing all at once, after a pause
Subslide =
    element subslide {
        (BlockDivision | List)+
    }

⟨5 Divisions⟩ ≡

Part =
    element part {
        MetaDataLinedTitle, Chapter+
    }
Chapter =
    element chapter {
        MetaDataLinedTitle,
        AuthorByline*,
        (
            (
                Objectives?,
                (BlockDivision | Paragraphs)+,
                (Worksheet? & Handout? & ReadingQuestions? & Exercises? &
                 Solutions? & References? & Glossary?),
                Outcomes?
            )
        |
            (
                (Objectives? & IntroductionCompanion?),
                (Section | Printout),
                (Section | Printout | ReadingQuestions | Exercises |
                 Solutions | References | Glossary)*,
                (Outcomes? & ConclusionCompanion?)
            )
        )
    }
Section =
    element section {
        MetaDataLinedTitle,
        AuthorByline*,
        (
            (
                Objectives?,
                (BlockDivision | Paragraphs)+,
                (Worksheet? & Handout? & ReadingQuestions? & Exercises? &
                 Solutions? & References? & Glossary?),
                Outcomes?
            )
        |
            (
                (Objectives? & IntroductionCompanion?),
                (Subsection | Printout),
                (Subsection | Printout | ReadingQuestions | Exercises |
                 Solutions | References | Glossary)*,
                (Outcomes? & ConclusionCompanion?)
            )
        )
    }
Subsection =
    element subsection {
        MetaDataAltTitle,
        AuthorByline*,
        (
            (
                Objectives?,
                (BlockDivision | Paragraphs)+,
                (Worksheet? & Handout? & ReadingQuestions? & Exercises? &
                 Solutions? & References? & Glossary?),
                Outcomes?
            )
        |
            (
                (Objectives? & IntroductionCompanion?),
                (Subsubsection | Printout),
                (Subsubsection | Printout | ReadingQuestions | Exercises |
                 Solutions | References | Glossary)*,
                (Outcomes? & ConclusionCompanion?)
            )
        )
    }
Subsubsection =
    element subsubsection {
        MetaDataAltTitle,
        AuthorByline*,
        Objectives?,
        (BlockDivision | Paragraphs)+,
        (Worksheet? & Handout? & ReadingQuestions? & Exercises? &
         Solutions? & References? & Glossary?),
        Outcomes?
    }
ArticleAppendix =
    element appendix {
        MetaDataAltTitle,
        AuthorByline*,
        (
            (
                Objectives?,
                (BlockDivision | Paragraphs | NotationList)+,
                (Worksheet? & Handout? & ReadingQuestions? & Exercises? &
                 Solutions? & References? & Glossary?),
                Outcomes?
            )
        |
            (
                (Objectives? & IntroductionCompanion?),
                (Subsection | Printout),
                (Subsection | Printout | ReadingQuestions | Exercises |
                 Solutions | References | Glossary)*,
                (Outcomes? & ConclusionCompanion?)
            )
        |
            (
                HeadNote?,
                NotationList
            )
        )
    }
BookAppendix =
    element appendix {
        MetaDataAltTitle,
        AuthorByline*,
        (
            (
                Objectives?,
                (BlockDivision | Paragraphs | NotationList)+,
                (Worksheet? & Handout? & ReadingQuestions? & Exercises? &
                 Solutions? & References? & Glossary?),
                Outcomes?
            )
        |
            (
                (Objectives? & IntroductionCompanion?),
                (Section | Printout),
                (Section | Printout | ReadingQuestions | Exercises |
                 Solutions | References | Glossary)*,
                (Outcomes? & ConclusionCompanion?)
            )
        |
            (
                HeadNote?,
                NotationList
            )
        )
    }
IndexDivision =
    element index {
        MetaDataAltTitleOptional,
        HeadNote?,
        IndexList
    }

⟨6 Paragraphs division⟩ ≡

Paragraphs =
    element paragraphs {
        MetaDataTitle,
        Index*,
        BlockDivision+
    }
ParagraphsNoNumber =
    element paragraphs {
        MetaDataTitle,
        Index*,
        BlockStatementNoNumber+
    }

⟨7 Specialized divisions⟩ ≡

ReadingQuestions =
    element reading-questions {
        MetaDataAltTitleOptional,
        IntroductionDivision?,
        Exercise+,
        ConclusionDivision?
    }
Exercises =
    element exercises {
        MetaDataAltTitleOptional,
        IntroductionDivision?,
        (
            (Exercise | ExerciseGroup)+ |
            Subexercises+
        ),
        ConclusionDivision?
    }
Subexercises =
    element subexercises {
        MetaDataAltTitleOptional,
        IntroductionDivision?,
        (Exercise | ExerciseGroup)+,
        ConclusionDivision?
    }
Solutions =
    element solutions {
        MetaDataAltTitleOptional,
        attribute inline {text}?,
        attribute divisional {text}?,
        attribute project {text}?,
        attribute admit {"all"|"odd"|"even"}?,
        IntroductionDivision?,
        ConclusionDivision?
    }
# A "references" is a list-like division: its one preface
# is a "headnote", and it has no "conclusion"
References =
    element references {
        MetaDataAltTitleOptional,
        HeadNote?,
        BibliographyItem+
    }
Glossary =
    element glossary {
        MetaDataAltTitleOptional,
        HeadNote?,
        GlossaryItem+
    }

⟨8 Solutions (experimental)⟩ ≡

Solutions |=
    element solutions {
        MetaDataAltTitleOptional,
        attribute inline {text}?,
        attribute divisional {text}?,
        attribute project {text}?,
        attribute worksheet {text}?,
        attribute reading {text}?,
        attribute scope {text}?,
        attribute admit {"all"|"odd"|"even"}?,
        IntroductionDivision?,
        ConclusionDivision?
    }

⟨9 Printout⟩ ≡

PrintoutAttributes =
    attribute margin { text }?,
    attribute top { text }?,
    attribute bottom { text }?,
    attribute right { text }?,
    attribute left { text }?

PrintoutBlock =
    BlockDivision | Paragraphs

# Page can contain a printout block or be empty
Page =
    element page {
        PrintoutBlock+ | empty
    }
# Main worksheet definition
Worksheet =
    element worksheet {
        PrintoutAttributes,
        attribute courseid {text}?,
        attribute series {text}?,
        attribute seriescode {text}?,
        MetaDataAltTitleOptional,
        (Objectives? & IntroductionDivision?),
        (Page+ | PrintoutBlock+),
        (Outcomes? & ConclusionDivision?)
    }

# Main handout definition
Handout =
    element handout {
        PrintoutAttributes,
        MetaDataAltTitleOptional,
        (Objectives? & IntroductionDivision?),
        (Page+ | PrintoutBlock+),
        (Outcomes? & ConclusionDivision?)
    }

# A printout is a worksheet or a handout
Printout =
    Worksheet | Handout

⟨10 Running text⟩ ≡

TextSimple = mixed {
    Character* }
TextShort = mixed { (
    Character |
    Generator |
    Verbatim |
    Group |
    MathInline |
    Music)* }
TextLongContent =
    Character |
    Generator |
    Verbatim |
    Group |
    MathInline |
    Music |
    Reference |
    Custom |
    WWVariable
TextLong =  mixed { (TextLongContent)* }

⟨11 Paragraphs⟩ ≡

# The union is named so extensions (e.g. the development
# schema) can widen it with a choice-combine ("|=")
TextParagraphItem =
    Character |
    Generator |
    Verbatim |
    Group |
    WWVariable |
    MathInline |
    Music |
    Reference |
    Custom |
    CodeDisplay |
    MathDisplay |
    List |
    Footnote |
    Notation |
    Index
TextParagraph = mixed { TextParagraphItem* }
Paragraph =
    element p {
        UniqueID?,
        LabelID?,
        Component?,
        attribute workspace {text}?,
        # pausing, within a slideshow
        attribute pause {"yes" | "no"}?,
        TextParagraph
    }
ParagraphLined =
    element p {
        UniqueID?,
        LabelID?,
        Component?,
        element line {TextShort}+
    }

⟨12 Delimiter characters⟩ ≡

Character =
    element lsq {empty} |
    element rsq {empty} |
    element rq {empty} |
    element lq {empty} |
    element ldblbracket {empty} |
    element rdblbracket {empty} |
    element langle {empty}|
    element rangle {empty}

⟨13 Dash characters⟩ ≡

Character |=
    element nbsp {empty} |
    element ndash {empty} |
    element mdash {empty}

⟨14 Arithmetic characters⟩ ≡

Character |=
    element minus {empty} |
    element times {empty} |
    element solidus {empty} |
    element obelus {empty} |
    element plusminus {empty} |
    element degree {empty} |
    element prime {empty} |
    element dblprime {empty}

⟨15 Exotic characters⟩ ≡

CopyrightCharacter =
    element copyright {empty}
Character |=
    element ellipsis {empty} |
    element midpoint {empty} |
    element swungdash {empty} |
    element permille {empty} |
    element pilcrow {empty} |
    element section-mark {empty} |
    element copyleft {empty} |
    CopyrightCharacter |
    element registered {empty} |
    element trademark {empty} |
    element phonomark {empty} |
    element servicemark {empty}

⟨16 Icon characters⟩ ≡

Character |=
    element icon {
        attribute name {text}
    }

⟨17 Keyboard characters⟩ ≡

Character |=
    element kbd {
        (text | attribute name {text})
    }

⟨18 Music characters⟩ ≡

MusicFlat =
    element flat {empty}
MusicSharp =
    element sharp {empty}
Music =
    element doublesharp {empty} |
    MusicSharp |
    element natural {empty} |
    MusicFlat |
    element doubleflat {empty} |
    element scaledeg {"0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"|"10"} |
    element timesignature {
        attribute top {text},
        attribute bottom {text}
    } |
    element n {
        attribute pc {
            "A"|"B"|"C"|"D"|"E"|"F"|"G"|"a"|"b"|"c"|"d"|"e"|"f"|"g"|
            "1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"|"10"
        },
        attribute acc {"doublesharp"|"sharp"|"flat"|"doubleflat"}?,
        attribute octave {"1"|"2"|"3"|"4"|"5"}?
    } |
    element chord {
        attribute root {text}?,
        attribute mode {text}?,
        attribute bps {text}?,
        attribute bass {text}?,
        attribute suspended {"yes"|"no"}?,
        attribute parentheses {"yes"|"no"}?,
        element alteration {
            (TextSimple |
            MusicSharp |
            MusicFlat)*
        }*
    }

⟨19 Characters⟩ ≡

⟨Dash characters 13⟩
⟨Delimiter characters 12⟩
⟨Arithmetic characters 14⟩
⟨Exotic characters 15⟩
⟨Icon characters 16⟩
⟨Keyboard characters 17⟩
⟨Music characters 18⟩

⟨20 Text generators⟩ ≡

Generator =
    element today {empty} |
    element timeofday {empty} |
    element tex {empty} |
    element latex {empty} |
    element xetex {empty} |
    element xelatex {empty} |
    element pretext {empty} |
    element prefigure {empty} |
    element webwork {empty} |
    element ad {empty} |
    element am {empty} |
    element bc {empty} |
    element ca {empty} |
    element eg {empty} |
    element etal {empty} |
    element etc {empty} |
    element ie {empty} |
    element nb {empty} |
    element pm {empty} |
    element ps {empty} |
    element vs {empty} |
    element viz {empty}

⟨21 Fill-in blank character⟩ ≡

FillInText =
    element fillin {
        attribute characters {xsd:integer}?,
        attribute rows {xsd:integer}?,
        attribute cols {xsd:integer}?,
        empty
    }
Generator |=
    FillInText

⟨22 SI units⟩ ≡

UnitSpecification =
        attribute prefix {text}?,
        attribute base {text},
        attribute exp {xsd:integer}?
Generator |=
    element quantity {
        element mag {text}?,
        element unit {UnitSpecification}*,
        element per {UnitSpecification}*
    }

⟨23 Verbatim text⟩ ≡

Verbatim =
    element c {text} |
    Email |
    element pf {
        attribute language {text}?,
        text
    }

⟨24 Abbreviations⟩ ≡

Group |=
    element abbr {TextSimple} |
    element acro {TextSimple} |
    element init {TextSimple}

⟨25 Delimited groups⟩ ≡

Group |=
    element q {TextLong} |
    element sq {TextLong} |
    element angles {TextLong} |
    element dblbrackets {TextLong}

⟨26 Highlighted groups⟩ ≡

Group |=
    element em {TextLong} |
    element term {TextLong} |
    element alert {TextLong} |
    element pubtitle {TextLong} |
    element articletitle {TextLong} |
    element foreign {
      XMLLang?,
      TextLong
    }

⟨27 Editing groups⟩ ≡

Group |=
    element delete {TextLong} |
    element insert {TextLong} |
    element stale {TextLong}

⟨28 XML syntax groups⟩ ≡

Group |=
    element tag {text} |
    element tage {text} |
    element attr {text}

⟨29 Taxonomic groups⟩ ≡

Group |=
    element taxon {
        attribute ncbi {xsd:integer}?,
        (
            text |
            (
                element genus {text}?,
                element species {text}?
            )
        )
    }

⟨30 Text groups⟩ ≡

⟨Abbreviations 24⟩
⟨Delimited groups 25⟩
⟨Highlighted groups 26⟩
⟨Editing groups 27⟩
⟨XML syntax groups 28⟩
⟨Taxonomic groups 29⟩

⟨31 Mathematics⟩ ≡

FillInMath = element fillin {
                 (attribute fill{text}?|attribute characters {xsd:integer}?),
                 empty
             }
# named so extensions can widen it ("|=")
MathInlineItem = FillInMath | WWVariable
MathInline =
    element m {
        mixed {MathInlineItem*}
    }
TagSymbol = "star" | "dstar" | "tstar" |
            "dagger" | "ddagger" | "tdagger" |
            "daggerdbl" | "ddaggerdbl" | "tdaggerdbl" |
            "hash" | "dhash" | "thash" |
            "maltese" | "dmaltese" | "tmaltese"
MathRow =
    element mrow {
        MetaDataTarget,
        (
            attribute number {"yes" | "no"} |
            attribute tag { TagSymbol }
        )?,
        attribute break {"yes" | "no"}?,
        mixed {MathRowItem*}
    }
# named so extensions can widen it ("|=")
MathRowItem = Xref | FillInMath | WWVariable
MathIntertext = element intertext {TextLong}
MathDisplay =
    element md {
        # common to both forms
        Component?,
        Index*,
        (
            # single-line: text content, optional @xml:id
            # makes it a cross-reference target, no @label;
            # @number and @tag are mutually exclusive,
            # @number defaults to "no"
            (
                UniqueID?,
                (
                    attribute number {"yes" | "no"} |
                    attribute tag { TagSymbol }
                )?,
                mixed {MathRowItem*}
            ) |
            # multi-line: "mrow" content, not itself a
            # cross-reference target, so no @xml:id, no @label;
            # @number defaults to "no" and applies to each "mrow".
            # Each "intertext" must be sandwiched between "mrow":
            # it cannot lead, cannot trail, and two cannot be
            # adjacent.
            (
                attribute number {"yes" | "no"}?,
                attribute break {"yes" | "no"}?,
                attribute alignment {"align" | "gather" | "alignat"}?,
                attribute alignat-columns {text}?,
                MathRow, (MathRow | (MathIntertext, MathRow))*
            )
        )
    }

⟨32 Blocks⟩ ≡

BlockText =
    Paragraph | BlockQuote | Preformatted |
    Image | Video | Audio | Program | Console | Tabular
BlockStatementNoNumber =
    BlockText | Aside |
    SideBySideNoNumber | SideBySideGroupNoNumber
BlockStatement =
    BlockText |
    Figure | Aside |
    SideBySide | SideBySideGroup | Sage
BlockSolution =
    BlockStatement | Proof
BlockDivision =
    BlockStatement |
    Remark | Computation | Theorem | Proof | Definition |
    Axiom | Example | Exercise | Project | OpenProblem |
    Poem | Assemblage | ListGenerator | Fragment

⟨33 Common components of blocks⟩ ≡

Prelude =
    element prelude {BlockText+}
Postlude =
    element postlude {BlockText+}
Statement =
    element statement {
        BlockStatement+
    }
Hint =
    element hint {
        MetaDataTitleOptional,
        BlockSolution+
    }
Answer =
    element answer {
        MetaDataTitleOptional,
        BlockSolution+
    }
Solution =
    element solution {
        MetaDataTitleOptional,
        BlockSolution+
    }

⟨34 Introductions, conclusions, headnotes⟩ ≡

IntroductionText =
    element introduction {BlockText+}
ConclusionText =
    element conclusion {BlockText+}
IntroductionStatementNoNumber =
    element introduction {BlockStatementNoNumber+}
ConclusionStatementNoNumber =
    element conclusion {BlockStatementNoNumber+}
IntroductionStatement =
    element introduction {BlockStatement+}
ConclusionStatement =
    element conclusion {BlockStatement+}
IntroductionCompanion =
    element introduction {
        MetaDataNoTitle,
        BlockDivision+
    }
ConclusionCompanion =
    element conclusion {
        MetaDataNoTitle,
        BlockDivision+
    }
IntroductionDivision =
    element introduction {
        MetaDataTitleOptional,
        BlockDivision+
    }
ConclusionDivision =
    element conclusion {
        MetaDataTitleOptional?,
        BlockDivision+
    }
HeadNote =
    element headnote {BlockStatementNoNumber+}

⟨35 Cross-references⟩ ≡

XrefTextStyle =
    "local" | "global" | "hybrid" | "type-local" | "type-global" |
    "type-hybrid" | "phrase-global" | "phrase-hybrid" |
    "type-local-title" | "type-global-title" |
    "title" | "custom"
Reference = Url | Xref | DataUrl
Custom =
    element custom {
        attribute ref {text},
        empty
    }
DataUrl =
    element dataurl {
        (attribute href {text} | attribute source {text}),
        attribute visual {text}?,
        TextShort?
    }
Url =
    element url {
        attribute href {text},
        attribute visual {text}?,
        TextShort?
    }
Xref =
    element xref {
            (
                attribute ref {text} |
                (attribute first {text}, attribute last {text}) |
                attribute provisional {text}
            ),
            attribute text { XrefTextStyle }?,
            attribute detail {text}?,
            TextShort
    }
NotationDescription =
    element description {
        TextShort
    }
Notation =
    element notation {
        element usage {MathInline},
        NotationDescription
    }

⟨36 Footnotes⟩ ≡

Footnote =
    element fn {
        MetaDataTarget,
        TextLong
    }

⟨37 Index entries⟩ ≡

IdxHeading =
    element h {
        attribute sortby {text}?,
        TextShort
    }
Index =
    element idx {
        MetaDataTarget,
        attribute sortby {text}?,
        attribute start {text}?,
        attribute finish {text}?,
        (
            TextShort
        |
            (
            IdxHeading,
            IdxHeading?,
            IdxHeading?,
            (element see {TextShort} | element seealso {TextShort})?
            )
        )
    }
IndexList = element index-list {empty}

⟨38 Objectives and outcomes⟩ ≡

Objectives =
    element objectives {
        MetaDataTitleOptional,
        IntroductionText?,
        List,
        ConclusionText?
    }
Outcomes =
    element outcomes {
        MetaDataTitleOptional,
        IntroductionText?,
        List,
        ConclusionText?
    }

⟨39 Block quotes⟩ ≡

BlockQuote =
    element blockquote {
        MetaDataTitleOptional,
        Paragraph+,
        Attribution?
    }
SimpleLine =
    element line {TextSimple}
ShortLine =
    element line {TextShort}
LongLine =
    element line {TextLong}

⟨40 Verbatim displays⟩ ≡

CodeLine =
    element cline {text}
CodeDisplay =
    element cd {
        attribute latexsep {text}?,
        # "all" renders every space as a visible glyph; default "none"
        attribute showspaces {"all" | "none"}?,
        (text | CodeLine+)
    }
Preformatted =
    element pre {
        text | CodeLine+
    }
ConsoleOutput =
    element output {text}
ConsoleInput =
    element input {
        attribute prompt {text}?,
        attribute continuation {text}?,
        text
    }
Console =
    element console {
        Component?,
        attribute prompt {text}?,
        attribute continuation {text}?,
        attribute width {text}?,
        attribute margins {text}?,
        (
            ConsoleInput,
            ConsoleOutput?
        )+
    }
ProgramPreamble =
    element preamble {
        attribute visible {"yes"|"no"}?,
        text
    }
ProgramCode = element code {text}
ProgramPostamble =
    element postamble {
        attribute visible {"yes"|"no"}?,
        text
    }
ProgramTests =
    element tests {
        attribute visible {"yes"|"no"}?,
        (
            text
        |
            element iotest {
                element input {text},
                element output {text}
            }+
        )
    }
ProgramStdin =
    element stdin {
        text
    }
# A checkpoint's prompt and feedback are short bursts of
# marked-up text, not sequences of blocks
CodelensCheckpoint =
    element checkpoint {
        attribute line {text},
        (
            attribute answer {text}
        |
            attribute answer-variable {text}
        ),
        element prompt {TextLong},
        element feedback {TextLong}?
    }
Program =
    element program {
        Component?,
        LabelID?,
        UniqueID?,
        attribute width {text}?,
        attribute margins {text}?,
        attribute autorun {"yes"|"no"}?,
        attribute chatcodes {"yes"|"no"}?,
        attribute codelens {"yes"|"no"}?,
        attribute codetailor {"all"|"incorrect"}?,
        attribute codetailor-fallback {text}?,
        # the codelens trace step (1-based) to open on
        attribute starting-step {xsd:integer}?,
        attribute compiler-args {text}?,
        attribute extra-compiler-args {text}?,
        attribute database {text}?,
        attribute datafile {text}?,
        attribute add-files {text}?,
        attribute compile-also {text}?,
        attribute download {"yes"|"no"}?,
        attribute hidecode {"yes"|"no"}?,
        attribute highlight-lines {text}?,
        attribute include {text}?,
        attribute filename {text}?,
        attribute interactive {"codelens"|"activecode"|"no"}?,
        attribute interpreter-args {text}?,
        attribute language {text}?,
        attribute line-numbers {"yes"|"no"}?,
        attribute linker-args {text}?,
        attribute timelimit {text}?,
        attribute pck {text}?,
        attribute scene {text}?,
        (
            text
        |
            (
                ProgramPreamble?,
                ProgramCode,
                ProgramPostamble?,
                ProgramTests?,
                ProgramStdin?,
                CodelensCheckpoint*
            )
        )
    }

⟨41 Lists⟩ ≡

ListItem = element li {
    (
        (MetaDataTarget, TextParagraph)
    |
        (MetaDataTitleOptional, BlockStatement+)
    )
}
DefinitionListItem = element li {
    MetaDataTitle,
    BlockStatement+
}
List =
    element ol {
        Component?,
        attribute cols {"2"|"3"|"4"|"5"|"6"}?,
        attribute marker {text}?,
        # pausing, within a slideshow: items appear one at a time
        attribute pause {"yes" | "no"}?,
        ListItem+
    } |
    element ul {
        Component?,
        attribute cols {"2"|"3"|"4"|"5"|"6"}?,
        attribute marker {"disc" | "circle" | "square" | ""}?,
        attribute pause {"yes" | "no"}?,
        ListItem+
    } |
    element dl {
        Component?,
        attribute width {"narrow" | "medium" | "wide"}?,
        attribute pause {"yes" | "no"}?,
        DefinitionListItem+
    }

⟨42 Definitions⟩ ≡

DefinitionLike =
    attribute workspace {text}?,
    MetaDataTitleOptional,
    Notation*,
    Statement
Definition =
    element definition {DefinitionLike}

⟨43 Theorems, and similar⟩ ≡

Case =
    element case {
       MetaDataTitleOptional,
       attribute direction {text}?,
       BlockStatement+
       }
Proof =
    element proof {
        attribute ref {text}?,
        attribute text {XrefTextStyle}?,
        attribute workspace {text}?,
        MetaDataTitleOptional,
        (BlockStatement | Case)+
    }
TheoremLike =
    attribute workspace {text}?,
    MetaDataTitleCreatorOptional,
    (BlockStatement+ | (Statement, Proof*))
Theorem =
    element theorem {TheoremLike} |
    element lemma {TheoremLike} |
    element corollary {TheoremLike} |
    element claim {TheoremLike} |
    element proposition {TheoremLike} |
    element algorithm {TheoremLike} |
    element fact {TheoremLike} |
    element identity {TheoremLike}

⟨44 Proofs, and similar⟩ ≡

ProofLike =
    MetaDataTitleOptional,
    (BlockStatement | Case)+
Proof |=
    element proof {ProofLike} |
    element argument {ProofLike} |
    element justification {ProofLike} |
    element reasoning {ProofLike} |
    element explanation {ProofLike}

⟨45 Axioms, and similar⟩ ≡

AxiomLike =
    MetaDataTitleCreatorOptional,
    Statement
Axiom =
    element axiom {AxiomLike} |
    element principle {AxiomLike} |
    element conjecture {AxiomLike} |
    element heuristic {AxiomLike} |
    element hypothesis {AxiomLike} |
    element assumption {AxiomLike}

⟨46 Projects, and similar⟩ ≡

ProjectLike =
    attribute workspace {text}?,
    MetaDataTitleOptional,
    (
        (BlockStatement+) |
        (
           Prelude?,
           (
              (Statement, Hint*, Answer*, Solution*) |
              (Statement, Program, Hint*, Answer*, Solution*) |
              (IntroductionStatement?, Task+, ConclusionStatement?) |
              (IntroductionText?, WebWork, ConclusionText?)
           ),
           Postlude?
        )
    )
Project =
    element activity {ProjectLike} |
    element investigation {ProjectLike} |
    element exploration {ProjectLike} |
    element project {ProjectLike}
Task =
    element task {
        MetaDataTitleOptional,
        attribute workspace {text}?,
        (
            BlockStatement+ |
            (Statement, Hint*, Answer*, Solution*) |
            (IntroductionStatement?, Task+, ConclusionStatement?)
        )
    }

⟨47 Open problems, and similar⟩ ≡

OpenProblemLike =
    MetaDataTitleOptional,
    Prelude?,
    (
        (Statement, Discussion*) |
        (IntroductionStatement?, OpenProblemTask+, ConclusionStatement?)
    ),
    Postlude?
OpenProblem =
    element openproblem {OpenProblemLike} |
    element openquestion {OpenProblemLike} |
    element openconjecture {OpenProblemLike}
OpenProblemTask =
    element task {
        MetaDataTitleOptional,
        (
            (Statement, Discussion*) |
            (IntroductionStatement?, OpenProblemTask+, ConclusionStatement?)
        )
    }
Discussion =
    element context {DiscussionLike} |
    element discussion {DiscussionLike} |
    element opinion {DiscussionLike} |
    element status {DiscussionLike} |
    element suggestion {DiscussionLike}
DiscussionLike =
    MetaDataTitleOptional,
    BlockStatement+

⟨48 Remarks, and similar⟩ ≡

RemarkLike =
    MetaDataTitleOptional,
    BlockStatement+
Remark =
    element remark {RemarkLike} |
    element convention {RemarkLike} |
    element note {RemarkLike} |
    element observation {RemarkLike} |
    element warning {RemarkLike} |
    element insight {RemarkLike}

⟨49 Computation, and similar⟩ ≡

ComputationLike =
    MetaDataTitleOptional,
    BlockStatement+
Computation =
    element computation {ComputationLike} |
    element technology {ComputationLike} |
    element data {ComputationLike}

⟨50 Asides, and similar⟩ ≡

AsideLike =
    MetaDataTitleOptional,
    BlockText+
Aside =
    element aside {AsideLike} |
    element biographical {AsideLike} |
    element historical {AsideLike}

⟨51 Assemblages⟩ ≡

Assemblage =
    element assemblage {
        MetaDataTitleOptional,
        (BlockText | SideBySideNoNumber | SideBySideGroupNoNumber)+
    }

⟨52 Captioned and titled displays⟩ ≡

Caption =
    element caption {Component?, TextLong}
Landscape =
    attribute landscape {"yes" | "no"}
Figure =
    element figure {
        MetaDataCaption,
        Landscape?,
        (
            Image |
            Video |
            Audio |
            SideBySide |
            SideBySideGroup |
            MuseScore |
            Paragraph
        )
    } |
    FigureTable | FigureListing | FigureList
# the one route to a numbered, titled "tabular"
FigureTable =
    element table {
        MetaDataAltTitle,
        Landscape?,
        Tabular
    }
FigureListing =
    element listing {
        MetaDataAltTitle,
        Landscape?,
        (
            Program |
            Console
        )
    }
FigureList =
    element list {
        MetaDataAltTitle,
        Landscape?,
        IntroductionText?,
        List,
        ConclusionText?
    }

⟨53 Tabular display⟩ ≡

BorderThickness = "none" | "minor" | "medium" | "major"
BorderTop =
    attribute top {BorderThickness}
BorderBottom =
    attribute bottom {BorderThickness}
BorderLeft =
    attribute left {BorderThickness}
BorderRight =
    attribute right {BorderThickness}
AlignmentHorizontal =
    attribute halign {"left" | "center" | "right" | "justify"}
AlignmentVertical =
    attribute valign {"top" | "middle" | "bottom"}

# A table cell takes "tn" table notes, not "fn" footnotes.  A
# table note is lettered a, b, c per-tabular in reading order
# and is placed below the table, disjoint from the numbering
# of true footnotes.  Notes to tables: CMoS 18th ed.,
# 3.77-3.81; the specific (lettered) notes here are 3.80.
# A "tn" is not a cross-reference target, so takes no
# identification attributes.
TableNote = element tn {TextLong}
TableCellText = mixed { (TextLongContent | TableNote)* }
TableCell =
    element cell {
        AlignmentHorizontal?,
        BorderBottom?,
        BorderRight?,
        attribute colspan {text}?,
        (
            TableCellText |
            LongLine+ |
            # a paragraph's content is the same everywhere, so a
            # cell of paragraphs anchors a table note after any
            # of them; assembly relocates the note's mark to the
            # end of the paragraph it follows
            (Paragraph, TableNote*)+
        )
    }
TableRow =
    element row {
        attribute header {"yes" | "no" | "vertical"}?,
        AlignmentHorizontal?,
        AlignmentVertical?,
        BorderBottom?,
        BorderLeft?,
        TableCell+
    }
TableColumn =
    element col {
        AlignmentHorizontal?,
        BorderTop?,
        BorderRight?,
        attribute width {text}?
    }
Tabular =
    element tabular {
        Component?,
        attribute width {text}?,
        attribute margins {text}?,
        attribute row-headers {"yes" | "no"}?,
        attribute break {"yes" | "no"}?,
        AlignmentHorizontal?,
        AlignmentVertical?,
        BorderTop?,
        BorderBottom?,
        BorderLeft?,
        BorderRight?,
        TableColumn*,
        TableRow+
    }

⟨54 Side-by-side layouts⟩ ≡

Stack =
    element stack {
        (
            Tabular |
            Image |
            Program |
            Console |
            Paragraph |
            Preformatted |
            List
        )+
    }
SidebySideAttributes =
    Component?,
    attribute margins {text}?,
    # pausing, within a slideshow
    attribute pause {"yes" | "no"}?,
    attribute landscape {"yes" | "no"}?,
    (attribute width {text} | attribute widths {text})?,
    (
        AlignmentVertical |
        attribute valigns { list { ("top" | "middle" | "bottom")+ } }
    )?
# A "figure" occupying a panel is restricted: the layout
# elements ("sidebyside", "sbsgroup") may not nest, and a
# static conversion realizes the media elements ("video",
# "audio") as a manufactured "sidebyside", so none of these
# may appear.  The schema stops these immediate routes; the
# validation-plus stylesheet polices arbitrary depth.
FigurePanel =
    element figure {
        MetaDataCaption,
        Landscape?,
        (
            Image |
            MuseScore |
            Paragraph
        )
    } |
    FigureTable | FigureListing | FigureList
# The panels themselves; a narrative "sidebyside" holds at
# least two, else nothing is side by side
Panel =
    FigurePanel |
    Poem |
    Tabular |
    Image |
    Program |
    Console |
    Paragraph |
    Preformatted |
    List |
    Stack |
    Exercise
PanelNoNumber =
    Poem |
    Tabular |
    Image |
    Program |
    Console |
    Paragraph |
    Preformatted |
    List |
    Stack
SideBySide =
    element sidebyside {
        SidebySideAttributes,
        Panel, Panel+
    }
SideBySideNoNumber =
    element sidebyside {
        SidebySideAttributes,
        PanelNoNumber, PanelNoNumber+
    }
# a group of one "sidebyside" is no group: the layout
# attributes might as well sit on the lone "sidebyside"
SideBySideGroup =
    element sbsgroup {
        UniqueID?,
        SidebySideAttributes,
        SideBySide, SideBySide+
    }
SideBySideGroupNoNumber =
    element sbsgroup {
        UniqueID?,
        SidebySideAttributes,
        SideBySideNoNumber, SideBySideNoNumber+
    }

⟨55 Images⟩ ≡

Image = ImageRaster | ImageCode | ImagePG
# An image drawn by the PG code of a WeBWorK problem, named
# by @pg-name.  Like "var", the form is admitted schema-wide
# (it can appear deep within list items, say) but is
# exclusive to a "webwork" problem; the validation-plus
# stylesheet enforces the location.
ImagePG =
    element image {
        attribute pg-name {text},
        attribute width {text}?,
        attribute margins {text}?,
        empty
    }
ImageDescription = element description {(Paragraph | Tabular)+}
# A "var" may ride along, per the schema-wide "var" pattern:
# the validation-plus stylesheet confines it to a WeBWorK problem
ImageShortDescription = element shortdescription {(text | WWVariable)*}
ImageShortDescriptionCode = element shortdescription {
    (text | WWVariable)+
}
ImageRaster =
    element image {
        UniqueID?,
        Component?,
        attribute width {text}?,
        attribute margins {text}?,
        # pausing, within a slideshow
        attribute pause {"yes" | "no"}?,
        attribute rotate {text}?,
        attribute archive {text}?,
        attribute source {text},
        (
          attribute decorative {"yes"} |
          (
            attribute decorative {"no"}?,
            (
              ImageShortDescription? &
              ImageDescription?
            )
          )
        )
    }
CodeLatexImage =
    element latex-image {
        LabelID?,
        Component?,
        text
    }
ImageCode =
    element image {
        UniqueID?,
        Component?,
        attribute width {text}?,
        attribute margins {text}?,
        # pausing, within a slideshow
        attribute pause {"yes" | "no"}?,
        attribute archive {text}?,
        (
          attribute decorative {"yes"} |
          (
            attribute decorative {"no"}?,
            (
              ImageShortDescriptionCode ? &
              ImageDescription? &
              (
                CodeLatexImage |
                element asymptote {
                  LabelID?,
                  Component?,
                  text
                } |
                element sageplot {
                    LabelID?,
                    Component?,
                    attribute variant {'2d'|'3d'}?,
                    attribute aspect {text}?,
                    text
                } |
                element mermaid {
                    LabelID?,
                    Component?,
                    text
                } |
                element pf:prefigure {
                    attribute label {text}?,
                    external "pf-adapter.rnc"
                }
              )
            )
          )
        )
    }
WWLatexImage = element latex-image {
    text
  }
ImageWW =
    element image {
        attribute pg-name {text}?,
        attribute width {text}?,
        (
          attribute decorative {"yes"} |
          (
            attribute decorative {"no"}?,
            (
              ImageShortDescriptionCode? &
              ImageDescription? &
              WWLatexImage?
            )
          )
        )
    }

⟨56 Sage code⟩ ≡

SageOutput = element output {text}
SageInput = element input {text}
Sage = element sage {
    Component?,
    attribute doctest {text}?,
    attribute tolerance {text}?,
    attribute auto-evaluate {'no'|'yes'}?,
    attribute language {text}?,
    attribute type {text}?,
    (SageInput, SageOutput?)?
}

⟨57 Interactives⟩ ≡

MuseScore =
    element score {
        attribute musescoreuser {text},
        attribute musescore {text}
    }

⟨58 Interactives⟩ ≡

Interactive =
    element interactive {
        UniqueID?,
        LabelID?,
        Component?,
        attribute aspect { text }?,
        attribute width { text }?,
        attribute platform { text }?,
        attribute preview { text }?,
        attribute iframe { text }?,
        attribute source { text }?,
        attribute version { text }?,
        attribute circuitjs { text }?,
        attribute calcplot3d { text }?,
        attribute geogebra { text }?,
        attribute desmos { text }?,
        # currently only consumed by the CalcPlot3D flavor;
        # widen this enum if another flavor adopts "@variant"
        attribute variant { "application" | "controls" | "minimal" }?,
        attribute dark-mode-enabled { text }?,
        attribute resize-behavior { text }?,
        attribute css { text }?,
        attribute design-width { text }?,
        attribute reset-icon { text }?,
        (
          ImageShortDescription? &
          ImageDescription? &
          (
            Slate |
            SideBySideInteractive |
            SideBySideGroupInteractive
          )* &
          element script { attribute type { text }?, text }* &
          element source { text }? &
          element instructions { mixed { MetaDataTitleOptional, BlockText+ } }? &
          element static { Image }?
        )

    }

# A "stack" occupying a panel of an interactive's
# "sidebyside" may also stack slates; a narrative
# "stack" may not
StackInteractive =
    element stack {
        (
            Tabular |
            Image |
            Program |
            Console |
            Paragraph |
            Preformatted |
            List |
            Slate
        )+
    }

# Within an "interactive" or a "slate", a "sidebyside" is
# scaffolding: it arranges slates, or narrows a lone panel
# to a chosen width, so the two-panel minimum of a
# narrative "sidebyside" is not imposed here
SideBySideInteractive =
    element sidebyside {
        SidebySideAttributes,
        ((PanelNoNumber | StackInteractive)+ | Slate+)
    }
SideBySideGroupInteractive =
    element sbsgroup {
        UniqueID?,
        SidebySideAttributes,
        SideBySideInteractive, SideBySideInteractive+
    }

Slate =
    element slate {
        UniqueID?,
        LabelID?,
        Component?,
        (
          JessieCodeAtt |
          (
            attribute surface { text },
            (
              attribute source { text } |
              attribute material { text }
            )?,
            attribute aspect { text }?,
            attribute perspective { text }?,
            (
              Paragraph |
              Tabular |
              SideBySideInteractive |
              AnyXHTML |
              text*
            )*
          )
        )
    }

  JessieCodeAtt =
    attribute surface {"jessiecode"},
    attribute axis {"true" | "false"}?,
    attribute grid {"true" | "false"}?,
    (
      attribute source {text} |
      text*
    )

  # A slate with surface="html" embeds an arbitrary XHTML
  # fragment, and the XHTML namespace is the author's
  # declaration that the content is foreign: anything
  # un-namespaced still gets the schema's full scrutiny.
  # Declare it once, as a prefix on the "slate" itself;
  # the conversion keeps only local names, so the output
  # page carries plain HTML tags, free of namespaces.
  AnyXHTML =
    element xhtml:* {
      (attribute * { text })*,
      mixed { AnyXHTML* }
    }

# add Interactives where used
BlockStatement |= Interactive

Figure |= element figure { MetaDataCaption, Interactive }

Exercises |= element exercises {
    MetaDataAltTitleOptional,
    IntroductionDivision?,
    (
    (Exercise | ExerciseGroup)+ |
    Subexercises+ | Interactive
    ),
    ConclusionDivision?
}

# Hosted on Runestone, an "exercises" division can be a
# timed exam (@time-limit in minutes; results, feedback,
# the visible timer, and pausing each default on), or can
# collect group-work submissions (@groupwork, group size
# capped by @groupsize); a "worksheet" can do the latter
Exercises |= element exercises {
    (
        (attribute time-limit {xsd:integer},
         attribute results {"yes"|"no"}?,
         attribute timer {"yes"|"no"}?,
         attribute feedback {"yes"|"no"}?,
         attribute pause {"yes"|"no"}?)
    |
        (attribute groupwork {"yes"|"no"},
         attribute groupsize {xsd:integer}?)
    ),
    MetaDataAltTitleOptional,
    IntroductionDivision?,
    (Exercise | ExerciseGroup)+,
    ConclusionDivision?
}
Worksheet |= element worksheet {
    attribute groupwork {"yes"|"no"},
    attribute groupsize {xsd:integer}?,
    PrintoutAttributes,
    attribute courseid {text}?,
    attribute series {text}?,
    attribute seriescode {text}?,
    MetaDataAltTitleOptional,
    (Objectives? & IntroductionDivision?),
    (Page+ | PrintoutBlock+),
    (Outcomes? & ConclusionDivision?)
}

⟨59 Video and audio⟩ ≡

Video =
    element video {
        UniqueID?,
        LabelID?,
        Component?,
        attribute width {text}?,
        attribute margins {text}?,
        attribute aspect {text}?,
        attribute start {xsd:integer}?,
        attribute end {xsd:integer}?,
        attribute play-at {"embed" | "popout" | "select"}?,
        attribute preview {"default" | "generic" | text}?,
        (AttributesSourceFile | AttributesNetwork | AttributesYouTube |
         AttributesYouTubePlaylist | AttributesVimeo),
        # names the video, as in a Runestone manifest
        Title?,
        Track*
    }
Audio =
    element audio {
        UniqueID?,
        LabelID?,
        Component?,
        attribute width {text}?,
        attribute margins {text}?,
        attribute start {xsd:integer}?,
        attribute end {xsd:integer}?,
        (AttributesSourceFile | AttributesNetwork)
    }
Track =
    element track {
        attribute kind {text},
        attribute listing {text}?,
        XMLLang?,
        attribute source {text},
        attribute default {"yes"}?
    }
AttributesSourceFile =
    attribute source {text}
AttributesNetwork =
    attribute href {text}
AttributesYouTube =
    attribute youtube {text}
AttributesYouTubePlaylist =
    attribute youtubeplaylist {text}
AttributesVimeo =
    attribute vimeo {text}

⟨60 Poems⟩ ≡

AlignmentPoem = attribute halign {"left" | "center" | "right"}
PoemAuthor =
    element author {
        AlignmentPoem?,
        TextShort
    }
Poem =
    element poem {
        MetaDataTitleOptional,
        AlignmentPoem?,
        PoemAuthor?,
        (PoemLine+ | Stanza+)
    }
Stanza =
    element stanza {
        MetaDataTitleOptional,
        PoemLine+
    }
PoemLine =
    element line {
        attribute indent {xsd:integer}?,
        TextShort
    }

⟨61 Exercises⟩ ≡

ExerciseBody =
    BlockStatement+
StatementExercise =
    element statement { ExerciseBody }
Exercise =
    element exercise {
        MetaDataTitleOptional,
        attribute number {text}?,
        attribute workspace {text}?,
        (
        ExerciseBody |
        (StatementExercise, Hint*, Answer*, Solution*) |
        (IntroductionStatement?, Task+, ConclusionStatement?) |
        (IntroductionText?, WebWork, ConclusionText?)
        )
    }
ExerciseGroup =
    element exercisegroup {
        MetaDataTitleOptional,
        attribute cols {"2"|"3"|"4"|"5"|"6"}?,
        IntroductionStatementNoNumber,
        Exercise+,
        ConclusionStatementNoNumber?
    }

⟨62 Exercises (experimental)⟩ ≡

MyOpenMath =
    MetaDataTitleOptional,
    IntroductionText?,
    element myopenmath {
        attribute problem {text},
        attribute params {text}?
    },
    ConclusionText?
TrueFalse =
    MetaDataTitleOptional,
    attribute number {text}?,
    element statement {
        attribute correct {"yes"|"no"},
        Paragraph
    },
    Feedback?, Hint*, Answer*, Solution*
MultipleChoice =
    MetaDataTitleOptional,
    attribute number {text}?,
    StatementExercise,
    element choices {
        attribute randomize {"yes"|"no"}?,
        attribute multiple-correct {"yes"|"no"}?,
        attribute cols {xsd:integer}?,
        Choice+
    },
    Hint*, Answer*, Solution*
Choice =
    element choice {
        attribute correct {"yes"|"no"}?,
        ((mixed {BlockText*})
        | (StatementExercise, Feedback?))
    }
# A horizontal SQL Parsons may name a grading database and
# carry raw unit tests; a horizontal layout may permit the
# reuse of blocks, where a source block carries an @xml:id
# (and no @order) and each use references it with @ref
Parsons =
        MetaDataTitleOptional,
        attribute number {text}?,
        attribute language {text}?,
        attribute adaptive {"yes"|"no"}?,
        attribute indentation {text}?,
        attribute database {text}?,
        StatementExercise,
        element blocks {
            attribute layout {"horizontal"}?,
            attribute randomize {"yes"|"no"}?,
            attribute reuse {"yes"|"no"}?,
            attribute numbered {"left"|"right"|"no"}?,
            ( (BlockOrdered | BlockSource)+ | BlockUnordered+ )
        },
        element tests {text}?,
        Hint*, Answer*, Solution*,
        (ParsonsProgramPreamble?, Program, ParsonsProgramPostamble?)?
# Fixed code surrounding a runnable Parsons solution.  These
# patterns stand apart so the element names can be revisited
# on their own: the plain "preamble" and "postamble" within
# a "program" are close cousins, and some later decision may
# unify them.
ParsonsProgramPreamble =
    element program-preamble {
        attribute indent {text}?,
        text
    }
ParsonsProgramPostamble =
    element program-postamble {
        attribute indent {text}?,
        text
    }
# Horizontal blocks hold short inline bursts (code via "c",
# mathematics, text); vertical blocks hold code lines or
# natural-language blocks
BlockBody =
    ((
        attribute correct {"yes"|"no"}?,
        mixed {BlockText?, CodeLine?, Verbatim?, MathInline?}+
    ) |
    (
        element choice {
            attribute correct {"yes"|"no"}?,
            mixed {BlockText?, CodeLine?, Verbatim?, MathInline?}+
        }+
    ))
BlockOrdered =
    element block {
        attribute order {xsd:integer},
        attribute name {text}?,
        attribute depends {text}?,
        attribute ref {text}?,
        BlockBody
    }
BlockSource =
    element block {
        UniqueID,
        attribute name {text}?,
        BlockBody
    }
BlockUnordered =
    element block {
        attribute name {text}?,
        attribute depends {text}?,
        BlockBody
    }
Matching =
    MetaDataTitleOptional,
    attribute number {text}?,
    StatementExercise,
    Feedback?,
    Matches,
    Hint*, Answer*, Solution*
Matches = (
    element cardsort {
        Match+
    } |
    element matching {
        element premise {
            attribute ref {text}?,
            TextLong
        }+,
        element response {
            UniqueID,
            attribute order {xsd:integer}?,
            TextLong
        }+
    })
# Premises and the response arrive in any order; a match
# with premises and no response, or a response and no
# premises, is a distractor
Match =
    element match {
        element premise {
            attribute order {xsd:integer}?,
            TextLong
        }*
        &
        element response {
            attribute order {xsd:integer}?,
            TextLong
        }?
    }
FreeResponse =
    MetaDataTitleOptional,
    attribute number {text}?,
    attribute attachment {"yes" | "no"}?,
    (
    (ExerciseBody, Response?) |
    (StatementExercise, Response?, Hint*, Answer*, Solution*) |
    (IntroductionStatement?, Task+, ConclusionStatement?)
    )
Response =
    element response {empty}


# Selectable areas
Area =
    element area {
        attribute correct {"yes"|"no"}?,
        TextLong
    }
TextLongAreas =  mixed { (
      Area |
      Character |
      Generator |
      Verbatim |
      GroupAreas |
      MathInline |
      Music |
      Reference |
      WWVariable)* }
GroupAreas |=
    element q {TextLongAreas} |
    element sq {TextLongAreas}
TextParagraphAreas = mixed { (
  Character |
  Generator |
  Verbatim |
  Group |
  WWVariable |
  MathInline |
  Music |
  Reference |
  CodeDisplay |
  MathDisplay |
  List |
  Footnote |
  Notation |
  Index |
  Area |
  GroupAreas)* }
ParagraphAreas =
    element p {
        UniqueID?,
        LabelID?,
        Component?,
        TextParagraphAreas
    }
# The areas come in three forms: paragraphs of prose, lines
# of code (@language names the language), or a tabular with
# clickable cells.  Trailing components in any order.
Areas =
    MetaDataTitleOptional,
    attribute number {text}?,
    StatementExercise,
    element areas {
      attribute language {text}?,
      (ParagraphAreas | ClineAreas | Tabular)+
    },
    (Feedback? & Hint* & Answer* & Solution*)
ClineAreas =
    element cline { mixed {Area*} }
# within the development schema, any tabular cell may hold
# a clickable area
TableCellText |= mixed { (TextLongContent | TableNote | Area)* }

# General feedback element; a short burst of marked-up text
# is as welcome as a sequence of blocks
Feedback =
    element feedback {
        MetaDataTitleOptional,
        (BlockSolution+ | TextLong)
    }
# A dynamic exercise's automatic solution can be declined
Solution |=
    element solution {
        attribute include-automatic {"yes"|"no"},
        MetaDataTitleOptional,
        BlockSolution+
    }
# Fill-in-the-blank exercises: a setup and an evaluation
# accompany the statement.  Content model per the FITB
# maintainer (Brian Walton), issue #2980.
# "setup" and "evaluation" are data rather than content:
# neither is rendered where it sits, so their placement
# carries no meaning and is left to the author.  They may
# precede the "statement" (natural when the statement
# refers to objects the setup defines) or trail the
# solutions.  The remaining order is the usual one for an
# exercise, with "statement" ahead of any "hint", "answer"
# or "solution"; nesting that sequence inside the
# interleave is what preserves it.
FillInBlank =
    MetaDataTitleOptional,
    attribute number {text}?,
    (
    Setup? &
    Evaluation &
    ( StatementExercise, (Hint* & Answer* & Solution*) )
    )
# Problem setup: imported javascript libraries, a configuration JSON for passing data,
# named objects defined sequentially (later ones
# may reference earlier ones), then optional raw-Javascript hooks.
# External libraries can be passed as relative path to asset (using @source),
# or as an https:// url to the library (using @url).
# A missing @seed makes any randomization unpredictable, so the
# FITB machinery warns; but setup has non-randomizing uses too.
Setup =
    element setup {
        attribute seed {text}?,
        element jsimports {
            element jslibrary {
                (attribute source {text} | attribute url {text})
            }+
        }?,
        element config-json {text}?,
        DEObject*,
        element setupScript {text}?,
        element postRenderScript {text}?
    }
DEObject =
    element de-object {
        attribute name {text},
        attribute context {"number" | "formula"},
        (DERandom | DENumber | DEExpression | DEEvaluate)
    }
# A random number; @distribution may grow beyond "discrete".
# @by defaults to 1; @nonzero omitted means "no".
DERandom =
    element de-random {
        attribute distribution {"discrete"},
        attribute min {text},
        attribute max {text},
        attribute by {text}?,
        attribute nonzero {"yes"}?,
        empty
    }
# Text parses to a formula representing a constant (no free
# variables).  N.B. @reduce here follows sample usage; the
# maintainer's description lists it only on de-expression
# and de-evaluate.
DENumber =
    element de-number {
        attribute reduce {"yes"}?,
        text
    }
# A formula; the content model follows @mode.  Outside a
# "de-object" there is no enclosing context, so the
# expression may declare its own with @context.
DEExpression =
    element de-expression {
        attribute reduce {"yes"}?,
        attribute context {"number" | "formula"}?,
        (
            (attribute mode {"formula"}?, text) |
            (attribute mode {"substitution"}, DEFormula, DEVariableValued) |
            (attribute mode {"derivative"}, DEFormula, DEVariableEmpty)
        )
    }
# The evaluated (numeric) version of a formula
DEEvaluate =
    element de-evaluate {
        attribute reduce {"yes"}?,
        DEFormula,
        DEVariableValued
    }
# A reference to some other formula, from which a new one is
# derived.  (de-random and de-number are technically possible
# here but have no practical use, so are not admitted.)
DEFormula =
    element formula {
        DEExpression | DEEvaluate | Eval
    }
# The variable of a substitution or evaluation carries its
# value; plain-text values happen to work as raw Javascript
# but are deliberately NOT valid
DEVariableValued =
    element variable {
        attribute name {text},
        (Eval | DENumber | DEExpression)
    }
# The variable of a differentiation is name-only
DEVariableEmpty =
    element variable {
        attribute name {text},
        empty
    }
# An inline reference to a named setup object: within
# mathematics it renders as the TeX form of the object,
# elsewhere as its plain string form.  Admitted anywhere
# text or mathematics occurs (statements, solutions,
# feedback of dynamic exercises are where it is useful).
Eval =
    element eval {
        attribute obj {text},
        empty
    }
# eval joins the inline unions (development schema only)
TextParagraphItem |= Eval
MathInlineItem |= Eval
MathRowItem |= Eval
Evaluation =
    element evaluation {
        attribute answers-coupled {"yes"|"no"}?,
        Evaluate+
    }
# An "evaluate" with @all="yes" tests correctness of ALL the
# blanks (optional; meaningful with several blanks).  The
# maintainer describes an optional trailing "feedback" here;
# observed usage places feedback inside "test", so both are
# admitted.
# A bare "evaluate", with no "test" at all, is deliberately
# allowed: when the paired "fillin" carries an @answer or an
# @ansobj, the correct test is implicit and gets synthesized
# (the assembly "exercise" pass, or the Runestone conversion
# for @ansobj).  The element itself is still required, one
# per blank, since the pairing is positional; the
# validation-plus stylesheet checks that count, which no
# grammar can express.
Evaluate =
    element evaluate {
        attribute name {text}?,
        attribute submit {text}?,
        attribute all {"yes"|"no"}?,
        FITBTest*,
        Feedback?
    }
# At most one test should carry @correct="yes", determining
# correctness of a submission (unclosed by this schema); with
# none, the provided answer or answer object is the default
# comparison.  A test holds a single numcmp or strcmp, OR any
# number of jscmp/mathcmp/logic combined with an implied AND.
# A bare "eval" or a bare constructor within a test is
# shorthand for a comparison with the submission; the
# assembly substitutes the full form
FITBTest =
    element test {
        attribute correct {"yes"|"no"}?,
        (FITBNumcmp | FITBStrcmp |
         (FITBJscmp | FITBMathcmp | FITBLogic |
          Eval | DENumber | DEExpression | DEEvaluate)+),
        Feedback?
    }
FITBComparison =
    FITBNumcmp | FITBStrcmp | FITBJscmp | FITBMathcmp | FITBLogic
FITBNumcmp =
    element numcmp {
        attribute use-answer {"yes"|"no"}?,
        attribute value {text}?,
        attribute tolerance {text}?,
        attribute min {text}?,
        attribute max {text}?,
        attribute object {text}?
    }
FITBStrcmp =
    element strcmp {
        attribute use-answer {"yes"|"no"}?,
        attribute literal {"yes"}?,
        attribute case {"insensitive"}?,
        attribute strip {"no"}?,
        text
    }
FITBJscmp =
    element jscmp {
        text
    }
# Compare the submission to the provided answer
# (@use-answer), to a named setup object (@obj), or to one
# constructed child object; two children compare with each
# other instead.  Children use the same building blocks as
# setup does.
FITBMathcmp =
    element mathcmp {
        (
            attribute use-answer {"yes"} |
            attribute obj {text} |
            ((DENumber | DEExpression | DEEvaluate | Eval),
             (DENumber | DEExpression | DEEvaluate | Eval)?)
        )?
    }
FITBLogic =
    element logic {
        attribute op {"and"|"or"|"not"},
        (FITBComparison)+
    }
# Extended fillin with interactive attributes (extends the inline
# text fill-in blank; the bare "FillIn" name was orphaned)
FillInText |=
    element fillin {
        attribute characters {xsd:integer}?,
        attribute cols {xsd:integer}?,
        attribute rows {xsd:integer}?,
        attribute width {text}?,
        attribute answer {text}?,
        attribute parser {text}?,
        attribute mode {"string"|"number"|"math"}?,
        attribute name {text}?,
        attribute ansobj {text}?,
        attribute fill {text}?
    }

# Datafile element for student data
Datafile =
    element datafile {
        UniqueID?,
        LabelID?,
        Component?,
        attribute filename {text},
        attribute rows {xsd:integer}?,
        attribute cols {xsd:integer}?,
        attribute editable {"yes"|"no"}?,
        # a non-editable datafile can start hidden
        attribute hide {"yes"|"no"}?,
        (
            element pre {
                attribute source {text}?,
                text
            } |
            Image
        )
    }
BlockStatement |= Datafile

# Query (poll/survey) element; results are private to the
# instructor unless @visibility says otherwise
Query =
    element query {
        LabelID?,
        attribute scale {xsd:integer}?,
        attribute visibility {"instructor"|"all"}?,
        StatementExercise,
        element choices {
            Choice+
        }?
    }
BlockStatement |= Query

# Coding exercise: an interactive program (typically
# activecode) whose "tests" hold unit tests
CodingExercise =
    MetaDataTitleOptional,
    attribute number {text}?,
    StatementExercise,
    Program,
    Hint*, Answer*, Solution*
# LEGACY fill-in ("fillin-basic" to the assembly classifier):
# empty "var" marks in the statement pair positionally with
# the "var" elements of the "setup", each holding conditions
# tried in order (a numeric interval via @number/@tolerance,
# or a @string regular expression), with optional feedback.
# The machinery is fully implemented, interactive and
# static, so the form is admitted here.  It will NEVER move
# to the stable schema: its only future is retirement in
# favor of the dynamic fill-in above.
FillInLegacy =
    MetaDataTitleOptional,
    attribute number {text}?,
    StatementExercise,
    element setup {
        element var {
            attribute case {"insensitive"}?,
            element condition {
                (
                    (attribute number {text},
                     attribute tolerance {text}?)
                |
                    attribute string {text}
                ),
                Feedback?
            }+
        }+
    },
    Hint*, Answer*, Solution*
# the empty mark in a statement, sized by @width
VarMark =
    element var {
        attribute width {xsd:integer}?,
        empty
    }
TextParagraphItem |= VarMark
# A select exercise poses one of several existing questions
# (variants), located by their @label values; @grade says
# how the graded variant is chosen: at random, by A/B
# experiment group, always the first listed (the others
# remain viewable), or any one the reader selects
Select =
    MetaDataTitleOptional,
    element select {
        attribute grade {"random"|"ab-experiment"|"first"|"any"}?,
        attribute questions {text},
        attribute experiment-name {text}?,
        empty
    }
# Include all exercise types in exercise and activity
Exercise |=
    element exercise {
        attribute workspace {text}?,
        (
        MyOpenMath |
        TrueFalse |
        MultipleChoice |
        Parsons |
        Matching |
        FreeResponse |
        FillInBlank |
        FillInLegacy |
        Areas |
        CodingExercise |
        Select
        )
    }
# STRICTLY EXPERIMENTAL, matching the sample's own alert:
# a dual exercise pairs a "dynamic" realization (typically
# an embedded interactive) with a "static" stand-in, and
# the assembly chooses one per output
Exercise |=
    element exercise {
        MetaDataTitleOptional,
        element dynamic {
            StatementExercise
        },
        element static {
            (
                (StatementExercise, Hint*, Answer*, Solution*)
            |
                (IntroductionStatement?, Task+, ConclusionStatement?)
            )
        }
    }
# STACK assessment exercise type
Exercise |=
    element exercise {
        MetaDataTitleOptional,
        IntroductionStatement?,
        element stack {
            LabelID?,
            attribute source {text}?
        },
        ConclusionStatement?
    }
ProjectLike |=
    MyOpenMath |
    TrueFalse |
    MultipleChoice |
    Parsons |
    Matching |
    FreeResponse |
    FillInBlank |
    Areas
# The assembly classifies "task" alongside "exercise" and the
# project-like blocks, and every interactive form is
# implemented within a "task", so the same union applies
Task |=
    element task {
        attribute workspace {text}?,
        (
        TrueFalse |
        MultipleChoice |
        Parsons |
        Matching |
        FreeResponse |
        FillInBlank |
        FillInLegacy |
        Areas |
        CodingExercise
        )
    }

⟨63 Bibliography⟩ ≡

TextBib = mixed { (Character | MathInline)* }
BibliographyItem =
    element biblio {
        MetaDataTarget,
        ((
            attribute type {"raw"},
            (TextLong |
            Ibid |
            BibTitle |
            BibYear |
            BibJournal |
            BibNumber |
            BibVolume |
            BibNote)*
        ) |
        (
            attribute type {"bibtex"},
            (BibTitle |
            BibAuthor |
            BibEditor |
            BibYear |
            BibJournal |
            BibNumber |
            BibVolume |
            BibSeries |
            BibPublisher |
            BibPages |
            BibPubnote |
            BibNote)*
        ) |
        (
            # A CSL-style entry, modeled on the CSL-JSON data
            # format.  Structured fields, all optional, in a fixed
            # canonical order.  With no CSL style active the fields
            # are rendered in this (document) order; with a style,
            # citeproc-py supplies the order from the CSL-JSON.
            attribute type {CSLType},
            CSLAuthor?,
            CSLEditor?,
            CSLTranslator?,
            BibTitle?,
            BibContainerTitle?,
            BibCollectionTitle?,
            BibGenre?,
            Edition?,
            BibVolume?,
            BibNumber?,
            BibIssue?,
            BibIssued?,
            BibAccessed?,
            BibPage?,
            BibPageFirst?,
            BibNumberOfPages?,
            BibPublisher?,
            BibPublisherPlace?,
            BibDOI?,
            BibISBN?,
            BibISSN?,
            BibURL?))
    }
# CSL-JSON item types, a curated scholarly subset
CSLType =
    "article" |
    "article-journal" |
    "article-magazine" |
    "article-newspaper" |
    "book" |
    "chapter" |
    "collection" |
    "dataset" |
    "document" |
    "entry" |
    "entry-dictionary" |
    "entry-encyclopedia" |
    "manuscript" |
    "paper-conference" |
    "patent" |
    "report" |
    "review" |
    "software" |
    "speech" |
    "thesis" |
    "webpage"
Ibid = element ibid {empty}
BibYear = element year {text}
BibJournal = element journal { TextBib }
BibNumber = element number {text}
BibVolume = element volume {text}
BibTitle = element title {TextLong}
BibNote = element note {UniqueID?, Paragraph+}
BibAuthor = element author {text}
BibEditor = element editor {text}
BibSeries = element series {text}
BibPublisher = element publisher {text}
# A BibTeX "pubnote" holds free-form publication information
BibPubnote = element pubnote {TextBib}
BibPages = element pages {
    (
        attribute start {text},
        attribute end {text},
        empty
    ) |
    (
        text
    )
    }
# CSL contributors carry structured "name" elements only.  The
# element names "author"/"editor" are deliberately shared with the
# plain-text BibTeX patterns above; the gating "@type" attribute
# keeps the two content models apart (a RELAX NG co-occurrence
# constraint).
CSLAuthor = element author {CSLName+}
CSLEditor = element editor {CSLName+}
CSLTranslator = element translator {CSLName+}
# A CSL "name": recognized parts in any order, or a literal string
CSLName =
    element name {
        (BibFamily |
        BibGiven |
        BibDroppingParticle |
        BibNonDroppingParticle |
        BibSuffix |
        BibStaticOrdering |
        BibLiteral)*
    }
BibFamily = element family {text}
BibGiven = element given {text}
BibDroppingParticle = element dropping-particle {text}
BibNonDroppingParticle = element non-dropping-particle {text}
BibSuffix = element suffix {text}
BibStaticOrdering = element static-ordering {text}
BibLiteral = element literal {text}
# CSL standard (string) fields
BibContainerTitle = element container-title {TextBib}
BibCollectionTitle = element collection-title {TextBib}
# A CSL "genre" gives a sub-type, e.g. "Ph.D. thesis"
BibGenre = element genre {text}
BibIssue = element issue {text}
BibPage = element page {text}
BibPageFirst = element page-first {text}
BibNumberOfPages = element number-of-pages {text}
BibPublisherPlace = element publisher-place {TextBib}
BibDOI = element DOI {text}
BibISBN = element ISBN {text}
BibISSN = element ISSN {text}
BibURL = element URL {text}
# CSL date variables; one "date" per point, two for a range
BibIssued = element issued {BibDate+}
BibAccessed = element accessed {BibDate+}
BibDate =
    element date {
        attribute year {text}?,
        attribute month {text}?,
        attribute day {text}?,
        empty
    }

⟨64 Glossary⟩ ≡

GlossaryItem =
    element gi {
        MetaDataTitle,
        BlockStatementNoNumber+
    }

⟨65 Examples, and similar⟩ ≡

ExampleLike =
    attribute workspace {text}?,
    MetaDataTitleOptional,
    (
        (BlockStatement)+ |
        (Statement, Hint*, Answer*, Solution*) |
        (IntroductionStatement?, Task+, ConclusionStatement?)
    )
Example =
    element example {ExampleLike} |
    element question {ExampleLike} |
    element problem {ExampleLike}

⟨66 WeBWorK⟩ ≡

WebWork = (WebWorkAuthored | WebWorkSource)
WebWorkSource =
    element webwork {
        attribute source {text}?,
        attribute seed {xsd:integer}?
    }
WWDescription =
    element description {
        (
            TextSimple |
            SimpleLine+
        )
    }
# A "webwork" with @copy is an empty, lightweight reference
# to another authored problem (perhaps reseeded); the
# assembly resolves it to a duplicate
WebWorkAuthored =
    element webwork {
        (
            UniqueID?,
            LabelID?,
            Component?,
            attribute seed {xsd:integer}?,
            WWDescription?,
            WWMacros?,
            element pg-code {text}?,
            (
                (StatementExerciseWW, HintWW?, SolutionWW?)
            |
                (IntroductionText?, TaskWW+, ConclusionText?)
            )
        ) |
        (
            UniqueID?,
            LabelID?,
            Component?,
            attribute copy {text},
            attribute seed {xsd:integer}?,
            empty
        ) |
        text
    }
BlockStatementWW =
            Paragraph |
            Preformatted |
            Tabular |
            ImageWW
StatementExerciseWW =
    element statement {
        (BlockStatementWW|WWInstruction)+
    }
TaskWW =
    element task {
        MetaDataTitleOptional,
        (
            (StatementExerciseWW, HintWW?, SolutionWW?) |
            (IntroductionText?, TaskWW+, ConclusionText?)
        )
    }
WWMacros =
    element pg-macros {
        element macro-file {text}+
    }
WWVariable =
    ## The WeBWorK "var" element appears in the RELAX-NG schema as a child of many elements, but almost always as a descendant of a "p" element or a "cell" element.  As an element that is only relevant for a WeBWorK problem, occurrences of "var" must be within a "webwork" element.  The validation-plus stylesheet will check on these two situations.
    element var {
        (attribute name {text},
        attribute evaluator {text}?,
        attribute width {text}?,
        # the variable holds PGML markup to be processed
        attribute data {"pgml"}?,
        attribute category {
                            "angle" | "decimal" | "exponent"
                          | "formula" | "fraction" | "inequality"
                          | "integer" | "interval" | "logarithm"
                          | "limit" | "number" | "point"
                          | "syntax" | "quantity" | "vector"
                          }?,
        attribute form {"popup"|"buttons"|"checkboxes"|"none"|"array"}?) |
        (attribute form {"essay"},
        attribute width {text}?)
    }
WWInstruction =
    element instruction {TextShort}
HintWW =
    element hint {
        (BlockStatementWW)+
    }
SolutionWW =
    element solution {
        (BlockStatementWW)+
    }

⟨67 Literate programming⟩ ≡

Fragment =
    element fragment {
        (
            attribute xml:id {text}
        |
            (
                attribute filename {text},
                attribute xml:id {text}?
             )
        ),
        Title,
        (
            element code {text} |
            element fragref {
                attribute ref {text}
            }
        )+
    }

⟨68 Frequent constructions⟩ ≡

⟨Attribution 69⟩
⟨Metadata 70⟩

⟨69 Attribution⟩ ≡

Attribution =
    element attribution {
        Component?,
        (TextLong | LongLine+)
    }

⟨70 Metadata⟩ ≡

UniqueID =
    attribute xml:id {text}
LabelID =
    attribute label {text}
Component =
    attribute component {text}
Title =
    element title {Component?, TextLong}
LinedTitle =
    element title {Component?, LongLine+}
Subtitle =
    element subtitle {Component?, TextLong}
LinedSubtitle =
    element subtitle {Component?, LongLine+}
ShortTitle =
    element shorttitle {Component?, TextShort}
PlainTitle =
    element plaintitle {Component?, text}
Creator =
    element creator {Component?, TextShort}
XMLLang = attribute xml:lang {text}
MetaDataTarget =
    UniqueID?,
    LabelID?,
    Component?,
    Index*
MetaDataTitle =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    Title,
    Index*
MetaDataAltTitle =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    Title,
    ShortTitle?,
    PlainTitle?,
    Index*
MetaDataLinedTitle =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    (Title | LinedTitle),
    ShortTitle?,
    PlainTitle?,
    Index*
MetaDataLinedSubtitle =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    (Title | LinedTitle),
    (Subtitle | LinedSubtitle)?,
    ShortTitle?,
    PlainTitle?,
    Index*
MetaDataNoTitle =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    Index*
MetaDataTitleOptional =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    Title?,
    Index*
MetaDataAltTitleOptional =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    (Title, ShortTitle?, PlainTitle?)?,
    Index*
MetaDataTitleCreatorOptional =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    Title?,
    Creator?,
    Index*
MetaDataCaption =
    UniqueID?,
    LabelID?,
    Component?,
    XMLLang?,
    Title?,
    Caption,
    Index*

⟨71 Miscellaneous or uncertain⟩ ≡

⟨72 List generator⟩ ≡

ListGenerator =
    element list-of {
        attribute elements {text},
        attribute scope {text}?,
        attribute divisions {text}?,
        attribute empty {"yes" | "no"}?
    }
NotationList =
    element notation-list {empty}

⟨73 Front matter⟩ ≡

ArticleFrontMatter =
    element frontmatter {
        MetaDataTitleOptional,
        Bibinfo,
        TitlePage,
        Abstract?
    }
BookFrontMatter = element frontmatter {
        MetaDataTitleOptional,
        Bibinfo,
        TitlePage,
        ColophonFront?,
        Biography*,
        Dedication?,
        Acknowledgement?,
        Preface*
    }
Bibinfo =
    element bibinfo {
        (
            (Author+, Editor*)
            |
            (Editor+)
        )?,
        ((Credit | ColophonCredit)* &
        Date? &
        Edition? &
        Event? &
        Keywords* &
        Support? &
        Website? &
        Copyright?)
    }
TitlePage =
    element titlepage {
        element titlepage-items {empty}
    }
Email = element email {text}
PersonName = element personname {TextSimple}
Affiliation =
    element affiliation {
        Position? &
        Department? &
        Institution? &
        Location?
    }
Position = element position {TextSimple | ShortLine+}
Department = element department {TextSimple | ShortLine+}
Institution = element institution {TextSimple | ShortLine+}
Support = element support {TextParagraph}
Location = element location {TextSimple | ShortLine+}
Keywords = element keywords {
    attribute authority {text}?,
    attribute variant {text}?,
    Title?,
    Keyword+
}
Keyword = element keyword {
    attribute primary {"yes"|"no"}?,
    TextSimple
}
Edition = element edition {text}
# "event" names the occasion of a presentation: the slideshow
# conversions (Beamer, reveal.js) read it, and an article's
# title page carries it as a line following the title.
Event = element event {
    TextLong
}
Author =
    element author {
        attribute corresponding {"yes" | "no"}?,
        attribute xml:id {text}?,
        PersonName,
        (
            (Position? & Department? & Institution? & Location?) |
            Affiliation+
        )?,
        Email?,
        Biography?,
        Support?
    }
Editor =
    element editor {
        PersonName,
        (
            (Position? & Department? & Institution? & Location?) |
            Affiliation+
        )?,
        Email?
    }
Credit =
    element credit {
        Title,
        Author+
    }
Date =
    element date {
        mixed {(Character | Generator)*}
    }
Abstract =
    element abstract {
        MetaDataTarget,
        BlockText+
    }
ColophonCredit = element credit {
        element role {TextShort},
        element entity {TextLong}
    }
ShortLicense = element shortlicense {TextLong}
Website = element website {Url}
Copyright =
    element copyright {
        element year {TextShort},
        element holder {text},
        element minilicense {TextShort}?,
        ShortLicense?
    }
ColophonFront =
    element colophon {
        MetaDataTarget,
        element colophon-items {empty}
    }
Biography =
    element biography {
        MetaDataTitleOptional,
        (BlockStatementNoNumber | ParagraphsNoNumber)+
    }
Dedication =
    element dedication {
        MetaDataTitleOptional,
        (Paragraph|ParagraphLined)+
    }
Acknowledgement =
    element acknowledgement {
        MetaDataTitleOptional,
        (BlockStatementNoNumber | ParagraphsNoNumber)+
    }
Preface =
    element preface {
        MetaDataTitleOptional,
        (
            (
                (BlockStatementNoNumber | ParagraphsNoNumber)+,
                Attribution*
            )
            |
            (
                (BlockStatementNoNumber | ParagraphsNoNumber )*,
                Contributors,
                (BlockStatementNoNumber | ParagraphsNoNumber)*
            )
        )
    }

⟨74 Front matter (dev)⟩ ≡

ShortLicense_X =
    element shortlicense {
        TextLong &
        Footnote*
    }
ShortLicense |= ShortLicense_X
Website_X = element website {
    element name {TextShort},
    element address {text}
}
Website |= Website_X

⟨75 Contributor⟩ ≡

Contributor =
    element contributor {
        MetaDataTarget,
        PersonName,
        (
            (
            Department?,
            Institution?,
            Location?
            )
            |
            Affiliation+
        )?,
        Email?
    }
Contributors =
    element contributors {
        Contributor+
    }
AuthorByline =
    element author {(TextSimple|Xref)}

⟨76 Back matter⟩ ≡

ArticleBackMatter =
    element backmatter {
        MetaDataTitleOptional,
        (ArticleAppendix|Solutions)*,
        Glossary?,
        References?,
        IndexDivision?,
        ColophonBack?
    }
BookBackMatter =
    element backmatter {
        MetaDataTitleOptional,
        (BookAppendix|Solutions)*,
        Glossary?,
        References?,
        IndexDivision?,
        ColophonBack?
    }
ColophonBack =
    element colophon {
        MetaDataTarget,
        (BlockText | SideBySideNoNumber | SideBySideGroupNoNumber)+
    }

⟨77 Document information⟩ ≡

DocInfo =
    element docinfo {
        Component?,
        XMLLang?,
        Configuration+
    }
⟨Preambles 78⟩
⟨LaTeX macros 79⟩
⟨Project initialism 80⟩
⟨Element renaming 81⟩
⟨Source directories 82⟩
⟨Author biographies 83⟩
⟨Authored-attribute defaults 84⟩
⟨DoenetML version 85⟩
⟨Page logo 86⟩
⟨Blurb 87⟩
⟨Document ID 88⟩

⟨78 Preambles⟩ ≡

Configuration |=
        element math-package {
            attribute latex-name {text},
            attribute mathjax-name {text}
        }*
Configuration |=
    element latex-image-preamble {text}
Configuration |=
    element asymptote-preamble {text}
Configuration |=
    element pf:prefigure-preamble {
        external "pf-preamble-adapter.rnc"
    }

⟨79 LaTeX macros⟩ ≡

Configuration |=
    element macros {text}

⟨80 Project initialism⟩ ≡

Configuration |=
    element initialism {text}

⟨81 Element renaming⟩ ≡

Configuration |=
    element rename {
        attribute element {text},
        attribute xml:lang {text}?,
        xsd:token { minLength = "1" }
    }

⟨82 Source directories⟩ ≡

Configuration |=
    element directories {
        attribute external {text}?,
        attribute data {text}?
    }

⟨83 Author biographies⟩ ≡

Configuration |=
    element author-biographies {
        attribute length {"short" | "long"}
    }

⟨84 Authored-attribute defaults⟩ ≡

Configuration |=
    element defaults {
        element images {
            attribute width {text}?,
            attribute margins {text}?
        }?
        &
        element programs {
            attribute language {text}?,
            attribute compiler-args {text}?,
            attribute download {"yes"|"no"}?,
            attribute linenumbers {"yes"|"no"}?,
            attribute linker-args {text}?,
            attribute interpreter-args {text}?,
            attribute timeout {text}?
        }?
        &
        element parsons {
            attribute language {text}?
        }?
        &
        element slides {
            attribute valign {"top" | "middle" | "bottom"}?
        }?
        &
        element xrefs {
            attribute text { XrefTextStyle }
        }?
    }

⟨85 DoenetML version⟩ ≡

Configuration |=
    element doenetml {
        attribute version {text}
    }

⟨86 Page logo⟩ ≡

Configuration |=
    element logo {
        attribute source {text},
        attribute llx {text},
        attribute lly {text},
        attribute width {text}?,
        attribute pages {"first" | "all"}?
    }

⟨87 Blurb⟩ ≡

Configuration |=
    element blurb {
        attribute shelf {text}?,
        text
    }

⟨88 Document ID⟩ ≡

Configuration |=
    element document-id {
        attribute edition {text}?,
        text
    }

⟨89 PreFigure Schema Adapter⟩ ≡

default namespace = "https://prefigure.org"
grammar {
    include "pf_schema.rnc"
}

⟨90 PreFigure Preamble Adapter⟩ ≡

default namespace = "https://prefigure.org"
grammar {
    include "pf_schema.rnc" {
        start =
            ( GraphicalElements* & GroupElements* )
    }
}

⟨91 Hierarchical Structure⟩ ≡

namespace pf = "https://prefigure.org"
grammar {
⟨Start elements 1⟩
⟨Gross structure 2⟩
⟨Document types 3⟩
⟨Slideshows 4⟩
⟨Divisions 5⟩
⟨Front matter 73⟩
⟨Back matter 76⟩
⟨Paragraphs division 6⟩
⟨Specialized divisions 7⟩
⟨Printout 9⟩
⟨Blocks 32⟩
⟨Common components of blocks 33⟩
⟨Introductions, conclusions, headnotes 34⟩
⟨Objectives and outcomes 38⟩
⟨Block quotes 39⟩
⟨Verbatim displays 40⟩
⟨Lists 41⟩
⟨Definitions 42⟩
⟨Theorems, and similar 43⟩
⟨Axioms, and similar 45⟩
⟨Examples, and similar 65⟩
⟨Projects, and similar 46⟩
⟨Open problems, and similar 47⟩
⟨Remarks, and similar 48⟩
⟨Computation, and similar 49⟩
⟨Asides, and similar 50⟩
⟨Assemblages 51⟩
⟨Captioned and titled displays 52⟩
⟨Side-by-side layouts 54⟩
⟨Images 55⟩
⟨Tabular display 53⟩
⟨Sage code 56⟩
⟨Interactives 57⟩
⟨Video and audio 59⟩
⟨Exercises 61⟩
⟨Poems 60⟩
⟨Bibliography 63⟩
⟨Glossary 64⟩
⟨Contributor 75⟩
⟨WeBWorK 66⟩
⟨Literate programming 67⟩
⟨Miscellaneous or uncertain 71⟩
⟨Frequent constructions 68⟩
⟨Paragraphs 11⟩
⟨Running text 10⟩
⟨Footnotes 36⟩
⟨Index entries 37⟩
⟨Cross-references 35⟩
⟨Mathematics 31⟩
⟨Verbatim text 23⟩
⟨Text groups 30⟩
⟨Text generators 20⟩
⟨Fill-in blank character 21⟩
⟨SI units 22⟩
⟨Characters 19⟩
⟨List generator 72⟩
⟨Document information 77⟩
}

⟨92 Development Schema⟩ ≡

namespace xhtml = "http://www.w3.org/1999/xhtml"
  grammar {

  include "pretext.rnc"
⟨Interactives 58⟩
⟨Front matter (dev) 74⟩
⟨Proofs, and similar 44⟩
⟨Solutions (experimental) 8⟩
⟨Exercises (experimental) 62⟩
}