bookish-press 0.4.45 → 0.4.47

package/{models/chapter/Parser.js → src/lib/models/chapter/Parser.ts}

@@ -1,3 +1,4 @@
+import type Edition from '../book/Edition';
 import CalloutNode from './CalloutNode';
 import ChapterNode from './ChapterNode';
 import CitationsNode from './CitationsNode';
@@ -8,6 +9,7 @@ import EmbedNode from './EmbedNode';
 import ErrorNode from './ErrorNode';
 import FootnoteNode from './FootnoteNode';
 import FormatNode from './FormatNode';
+import type { Format, FormatNodeSegmentType } from './FormatNode';
 import InlineCodeNode from './InlineCodeNode';
 import LabelNode from './LabelNode';
 import LinkNode from './LinkNode';
@@ -18,8 +20,13 @@ import Reference from '../book/Reference';
 import RuleNode from './RuleNode';
 import TableNode from './TableNode';
 import TextNode from './TextNode';
+import type Position from './Position';
+import type BlockNode from './BlockNode';
+import type Bookkeeping from './Bookkeeping';
+
 const numberedRE = /^[0-9]+\.+/;
 const bulletRE = /^\*+\s+/;
+
 // TODO This grammar is slightly out of date.
 // A simple recursive descent parser for this grammar.
 // Embeds a tokenizer, since the lexical grammar is simple.
@@ -45,16 +52,19 @@ const bulletRE = /^\*+\s+/;
 // LINK :: [CONTENT|TEXT]
 // FOOTNOTE :: {TEXT}
 // TEXT :: (.+)
+
 export default class Parser {
-    book;
-    text;
-    index;
-    openedDoubleQuote;
+    book: Edition | undefined;
+    text: string;
+    index: number;
+    openedDoubleQuote: boolean;
     // We pass this to all parsing functions to gather information strewn about the document.
-    metadata;
-    constructor(book, text) {
+    metadata: Bookkeeping;
+
+    constructor(book: Edition | undefined, text: string) {
         if (typeof text !== 'string')
             throw 'Parser expected a string but received ' + typeof text;
+
         this.book = book;
         this.text = text;
         this.index = 0; // Start at the first character.
@@ -63,65 +73,91 @@ export default class Parser {
             symbols: {},
         };
     }
-    static preprocessSymbols(book, text) {
+
+    static preprocessSymbols(book: Edition, text: string) {
         // Replace any remaining symbols with any definitions given.
         if (book && book.getSymbols()) {
-            for (const [symbol, definition] of Object.entries(book.getSymbols())) {
+            for (const [symbol, definition] of Object.entries(
+                book.getSymbols()
+            )) {
                 // Don't replace escaped at symbols. Otherwise, be liberal in replacing any matching symbol that starts with the symbol
                 // name and ends with a word boundary.
-                text = text.replace(new RegExp('([^\\\\])@' + symbol + '\\b', 'g'), '$1' + definition);
+                text = text.replace(
+                    new RegExp('([^\\\\])@' + symbol + '\\b', 'g'),
+                    '$1' + definition
+                );
             }
         }
         return text;
     }
-    static parseChapter(book, text) {
-        return new Parser(book, book === undefined ? text : Parser.preprocessSymbols(book, text)).parseChapter();
-    }
-    static parseFormat(book, text) {
-        return new Parser(book, book === undefined ? text : Parser.preprocessSymbols(book, text)).parseFormat();
-    }
-    static parseEmbed(book, text) {
-        return new Parser(book, book === undefined ? text : Parser.preprocessSymbols(book, text)).parseEmbed();
-    }
+
+    static parseChapter(book: Edition | undefined, text: string) {
+        return new Parser(
+            book,
+            book === undefined ? text : Parser.preprocessSymbols(book, text)
+        ).parseChapter();
+    }
+
+    static parseFormat(book: Edition | undefined, text: string) {
+        return new Parser(
+            book,
+            book === undefined ? text : Parser.preprocessSymbols(book, text)
+        ).parseFormat();
+    }
+
+    static parseEmbed(book: Edition | undefined, text: string) {
+        return new Parser(
+            book,
+            book === undefined ? text : Parser.preprocessSymbols(book, text)
+        ).parseEmbed();
+    }
+
     // Get the next character, if there is one, null otherwise.
-    peek() {
+    peek(): string | null {
         return this.more() ? this.text.charAt(this.index) : null;
     }
+
     // True if there are more characters to parse.
-    more() {
+    more(): boolean {
         return this.index < this.text.length;
     }
+
     nextIsEmptyParagraph() {
-        return (this.text.charAt(this.index) === '\n' &&
+        return (
+            this.text.charAt(this.index) === '\n' &&
             this.text.charAt(this.index + 1) === '\n' &&
-            this.text.charAt(this.index + 2) === '\n');
+            this.text.charAt(this.index + 2) === '\n'
+        );
     }
+
     nextIsWhitespace() {
-        return ((this.peek() === ' ' ||
-            this.peek() === '\t' ||
-            this.peek() === '\n') &&
-            !this.nextIsEmptyParagraph());
+        return (
+            (this.peek() === ' ' ||
+                this.peek() === '\t' ||
+                this.peek() === '\n') &&
+            !this.nextIsEmptyParagraph()
+        );
     }
+
     // Return the current character--if there is one-- and increment the index.
-    read(smarten = true) {
-        if (!this.more())
-            return null;
+    read(smarten = true): string | null {
+        if (!this.more()) return null;
+
         let char = this.text.charAt(this.index);
+
         if (smarten) {
-            if (char === '\n')
-                this.openedDoubleQuote = false;
+            if (char === '\n') this.openedDoubleQuote = false;
+
             // As we read, replace straight quotes with smart quotes.
             if (char === '"') {
                 // Replace left quotes after whitespace.
                 if (this.openedDoubleQuote) {
                     char = '\u201d';
-                }
-                else {
+                } else {
                     char = '\u201c';
                 }
                 this.openedDoubleQuote = !this.openedDoubleQuote;
-            }
-            else if (char === "'") {
+            } else if (char === "'") {
                 // If there's whitespace before this, it's a left single quote.
                 if (/\s/.test(this.text.charAt(this.index - 1)))
                     char = '\u2018';
@@ -130,53 +166,70 @@ export default class Parser {
                     char = '\u2019';
                 }
             }
-            if (char === '-' &&
+
+            if (
+                char === '-' &&
                 this.text.charAt(this.index + 1) === '-' &&
-                this.text.charAt(this.index) !== '\n') {
+                this.text.charAt(this.index) !== '\n'
+            ) {
                 this.index++;
                 char = '\u2014';
             }
         }
+
         // Advance to the next character in the document.
         this.index++;
+
         return char;
     }
-    unread() {
+
+    unread(): void {
         this.index--;
     }
+
     // All of the text including and after the current index.
-    rest() {
+    rest(): string {
         return this.text.substring(this.index);
     }
+
     // The character before
-    charBeforeNext() {
+    charBeforeNext(): string | null {
         return this.index === 0 ? null : this.text.charAt(this.index - 1);
     }
+
     // The character after
-    charAfterNext() {
+    charAfterNext(): string | null {
         return this.index === this.text.length - 1
             ? null
             : this.text.charAt(this.index + 1);
     }
+
     // All the text until the next newline
-    restOfLine() {
-        const nextNewline = this.text.substring(this.index).indexOf('\n') + this.index;
-        if (nextNewline < 0)
-            return this.text.substring(this.index);
+    restOfLine(): string {
+        const nextNewline =
+            this.text.substring(this.index).indexOf('\n') + this.index;
+        if (nextNewline < 0) return this.text.substring(this.index);
         else
-            return this.text.substring(this.index, Math.max(this.index, nextNewline));
+            return this.text.substring(
+                this.index,
+                Math.max(this.index, nextNewline)
+            );
     }
+
     // True if the given string is occurs next in the text.
-    nextIs(text) {
-        if (!this.more())
-            return false;
-        return (this.text.substring(this.index, this.index + text.length) === text);
+    nextIs(text: string) {
+        if (!this.more()) return false;
+        return (
+            this.text.substring(this.index, this.index + text.length) === text
+        );
     }
+
     // A critical list that tells inline formatting parsers to stop being greedy.
-    nextIsContentDelimiter() {
+    nextIsContentDelimiter(): boolean {
         const next = this.peek();
         const charAfterNext = this.charAfterNext();
-        return (next === '\n' ||
+        return (
+            next === '\n' ||
             next === '_' ||
             next === '*' ||
             next === '`' ||
@@ -190,56 +243,69 @@ export default class Parser {
             next === '{' ||
             (this.charBeforeNext() === ' ' && next === '%') ||
             next === '[' ||
-            next === '\\');
+            next === '\\'
+        );
     }
+
     // True if the next part of this string matches the given regular expression.
-    nextMatches(regex) {
-        if (!this.more())
-            return false;
+    nextMatches(regex: RegExp): boolean {
+        if (!this.more()) return false;
         return regex.test(this.rest());
     }
+
     // Returns true if all of the text between the current character and the next newline is whitespace.
-    isBlankLine() {
+    isBlankLine(): boolean {
         return this.restOfLine().trim() === '';
     }
+
     // Read until encountering something other than a tab or a space.
-    readWhitespace() {
+    readWhitespace(): void {
         let peek = this.peek();
         while (peek !== null && /^[ \t]/.test(peek)) {
             this.read();
             peek = this.peek();
         }
     }
+
     // Read until the end of the line.
-    readUntilNewLine() {
+    readUntilNewLine(): string {
         let text = '';
-        while (this.more() && this.peek() !== '\n')
-            text = text + this.read();
+        while (this.more() && this.peek() !== '\n') text = text + this.read();
         return text;
     }
+
     // Read until encountering the given string and return the read text.
-    readUntilNewlineOr(string) {
+    readUntilNewlineOr(string: string): string {
         let text = '';
         while (this.more() && !this.nextIs('\n') && !this.nextIs(string))
             text = text + this.read();
         return text;
     }
-    parseChapter() {
-        let blocks = [];
+
+    parseChapter(): ChapterNode {
+        let blocks: BlockNode[] = [];
+
         // Read any symbols declared for this chapter.
         this.parseSymbols();
+
         // Get the remaining text.
         let declarations = this.text.substring(0, this.index);
         let rest = this.rest();
+
         // First, replace any occurrences of the symbol with the symbol's text.
         for (const [symbol, text] of Object.entries(this.metadata.symbols)) {
-            rest = rest.replace(new RegExp('([^\\\\])@' + symbol + '\\b', 'g'), '$1' + text);
+            rest = rest.replace(
+                new RegExp('([^\\\\])@' + symbol + '\\b', 'g'),
+                '$1' + text
+            );
         }
+
         // Replace all of the remaining symbols using book symbol definitions.
-        if (this.book)
-            rest = Parser.preprocessSymbols(this.book, rest);
+        if (this.book) rest = Parser.preprocessSymbols(this.book, rest);
+
         // Replace the text with the pre-processed text.
         this.text = declarations + rest;
+
         // While there's more text, parse a line.
         let trailingNewlines = 0;
         while (this.more()) {
@@ -248,73 +314,90 @@ export default class Parser {
             blocks.push(this.parseBlock());
             // Read whitespace until we find the next thing.
             while (this.nextIsWhitespace()) {
-                if (this.peek() === '\n')
-                    trailingNewlines++;
+                if (this.peek() === '\n') trailingNewlines++;
                 this.read();
             }
         }
+
         // If there are no blocks, or the chapter ended with two newlines, append an empty paragraph with an empty format node and an empty text node.
         if (blocks.length === 0 || trailingNewlines > 1)
             blocks.push(new ParagraphNode());
+
         // Make the chapter node so we can pass it around.
         return new ChapterNode(blocks, this.metadata);
     }
+
     parseSymbols() {
         // Read whitespace before the symbols
         this.readWhitespace();
+
         // Keep reading symbols
         while (this.nextIs('@')) {
             // Read the @
             this.read();
+
             // Read the name.
             let name = this.readUntilNewlineOr(':');
+
             // Names need to be letter and numbers only.
             if (!/^[a-zA-Z0-9]+$/.test(name)) {
-                new ErrorNode(this.readUntilNewLine(), name.trim() === ''
-                    ? 'Did you mean to declare a symbol? Use an @ symbol, then a name of only numbers and letters, then a colon, then whatever content you want it to represent.'
-                    : "'" +
-                        name +
-                        "' isn't a valid name for a symbol; letters and numbers only");
+                new ErrorNode(
+                    this.readUntilNewLine(),
+                    name.trim() === ''
+                        ? 'Did you mean to declare a symbol? Use an @ symbol, then a name of only numbers and letters, then a colon, then whatever content you want it to represent.'
+                        : "'" +
+                          name +
+                          "' isn't a valid name for a symbol; letters and numbers only"
+                );
                 return;
             }
+
             // Read any whitespace until the colon.
             this.readWhitespace();
+
             // Name declarations need to be terminated with a colon before the block starts.
             if (!this.nextIs(':')) {
-                new ErrorNode(this.readUntilNewLine(), "Symbol names are to be followed by a ':'");
+                new ErrorNode(
+                    this.readUntilNewLine(),
+                    "Symbol names are to be followed by a ':'"
+                );
                 return;
             }
+
             // Read the colon
             this.read();
+
             // Read any whitespace after the colon.
             this.readWhitespace();
+
             // Remember where the text starts
             let startIndex = this.index;
+
             // Parse a block, any block.
             this.parseBlock();
+
             // Remember the text we parsed.
             this.metadata.symbols[name] = this.text
                 .substring(startIndex, this.index)
                 .trim();
+
             // Read whitespace until we find the next non-whitespace thing.
-            while (this.nextIsWhitespace())
-                this.read();
+            while (this.nextIsWhitespace()) this.read();
         }
     }
-    parseBlock() {
+
+    parseBlock(): BlockNode {
         // Read comment lines
         while (this.nextIs('%')) {
             this.readUntilNewLine();
         }
+
         // Parse and return a header if it starts with a hash
-        if (this.nextIs('#'))
-            return this.parseHeader();
+        if (this.nextIs('#')) return this.parseHeader();
         // Parse and return a horizontal rule if it starts with a dash
-        else if (this.nextIs('-'))
-            return this.parseRule();
+        else if (this.nextIs('-')) return this.parseRule();
         // Parse and return an embed if it starts with a bar
-        else if (this.nextIs('|'))
-            return this.parseEmbed();
+        else if (this.nextIs('|')) return this.parseEmbed();
         // Parse and return a bulleted or numbered list
         else if (this.nextMatches(bulletRE) || this.nextMatches(numberedRE))
             return this.parseList();
@@ -322,69 +405,75 @@ export default class Parser {
         else if (this.nextMatches(/^`[a-zA-Z!]*[ \t]*\n/))
             return this.parseCode();
         // Parse and return a quote block if it starts with "
-        else if (this.nextMatches(/^"[ \t]*\n/))
-            return this.parseQuote();
+        else if (this.nextMatches(/^"[ \t]*\n/)) return this.parseQuote();
         // Parse and return a callout if the line starts with =
-        else if (this.nextMatches(/^=[ \t]*\n/))
-            return this.parseCallout();
+        else if (this.nextMatches(/^=[ \t]*\n/)) return this.parseCallout();
         // Parse and return a table if the line starts with a ,
-        else if (this.nextIs(','))
-            return this.parseTable();
+        else if (this.nextIs(',')) return this.parseTable();
         // Parse the text as paragraph;
-        else
-            return this.parseParagraph();
+        else return this.parseParagraph();
     }
-    parseParagraph() {
+
+    parseParagraph(): ParagraphNode {
         if (this.nextIsEmptyParagraph()) {
             this.read();
             this.read();
             return new ParagraphNode(0, new FormatNode('', [new TextNode()]));
-        }
-        else
-            return new ParagraphNode(0, this.parseFormat());
+        } else return new ParagraphNode(0, this.parseFormat());
     }
-    parseHeader() {
+
+    parseHeader(): ParagraphNode {
         // Read a sequence of hashes
         let count = 0;
         while (this.nextIs('#')) {
             this.read();
             count++;
         }
+
         // Read any whitespace after the hashes.
         this.readWhitespace();
+
         // Parse some content.
         return new ParagraphNode(Math.min(3, count), this.parseFormat());
     }
-    parseRule() {
+
+    parseRule(): RuleNode {
         // Read until the end of the line. Ignore all text that follows.
         this.readUntilNewLine();
+
         return new RuleNode();
     }
-    parseList() {
+
+    parseList(): ListNode {
         let numbered = this.nextMatches(numberedRE);
-        const items = [];
+
+        const items: (FormatNode | ListNode)[] = [];
         let lastLevel = undefined;
         let currentLevel = undefined;
+
         // Keep parsing bullets until there aren't any. They must be of the same type, otherwise we stop.
         while (this.nextMatches(numberedRE) || this.nextMatches(bulletRE)) {
             numbered = this.nextMatches(numberedRE);
+
             // Remember the last level
             lastLevel = currentLevel;
+
             // Start the current level at 0
             currentLevel = 0;
+
             let digits = undefined;
             if (numbered) {
                 // Read the digits and remember how many there were so we can backtrack.
                 digits = this.index;
                 this.readUntilNewlineOr('.');
                 digits = this.index - digits;
+
                 // Figure out this level.
                 while (this.nextIs('.')) {
                     this.read();
                     currentLevel++;
                 }
-            }
-            else {
+            } else {
                 // Figure out this level.
                 currentLevel = 0;
                 while (this.nextIs('*')) {
@@ -392,15 +481,18 @@ export default class Parser {
                     currentLevel++;
                 }
             }
+
             // If this is the first bullet, or its the same level, just parse another bullet.
             if (lastLevel === undefined || lastLevel === currentLevel) {
                 // Read the whitespace after the bullet.
                 this.readWhitespace();
                 // Parse content after the bullet.
                 const format = this.parseFormat();
-                items.push(format.isEmpty()
-                    ? format.withSegmentAppended(new TextNode())
-                    : format);
+                items.push(
+                    format.isEmpty()
+                        ? format.withSegmentAppended(new TextNode())
+                        : format
+                );
             }
             // Otherwise, unread the stars, then either stop parsing or parse nested list.
             else {
@@ -410,6 +502,7 @@ export default class Parser {
                     this.unread();
                     count--;
                 }
+
                 // Unread the digits if there are any
                 if (digits !== undefined) {
                     while (digits > 0) {
@@ -417,9 +510,9 @@ export default class Parser {
                         digits--;
                     }
                 }
+
                 // If this new bullet is a lower level, then stop reading bullets.
-                if (currentLevel < lastLevel)
-                    break;
+                if (currentLevel < lastLevel) break;
                 // Otherwise, it's greater, and we should read another list.
                 else {
                     items.push(this.parseList());
@@ -427,6 +520,7 @@ export default class Parser {
                     currentLevel = lastLevel;
                 }
             }
+
             // Read trailing whitespace and newlines.
             this.readWhitespace();
             while (this.nextIsWhitespace()) {
@@ -435,19 +529,23 @@ export default class Parser {
                 // Read whitespace before the next block.
                 this.readWhitespace();
             }
+
             // Stop if we reach an empty paragraph.
-            if (this.nextIsEmptyParagraph())
-                break;
+            if (this.nextIsEmptyParagraph()) break;
         }
         return new ListNode(items, numbered);
     }
-    parseCode() {
+
+    parseCode(): CodeNode {
         // Parse the back tick
         this.read();
+
         // Parse through the next new line
         let language = this.readUntilNewLine();
+
         // Read the newline
         this.read();
+
         // Read until we encounter a closing back tick.
         let code = '';
         while (this.more() && !this.nextIs('`')) {
@@ -460,142 +558,172 @@ export default class Parser {
             }
             code = code + next;
         }
+
         // Trim the code.
         code = code.trim();
+
         // Read the backtick.
-        if (this.nextIs('`'))
-            this.read();
+        if (this.nextIs('`')) this.read();
+
         let position = this.parsePosition();
+
         // Read the caption. Note that parsing inline content stops at a newline,
         // so if there's a line break after the last row, there won't be a caption.
         const caption = this.parseFormat();
+
         return new CodeNode(new TextNode(code), language, position, caption);
     }
-    parsePosition() {
-        let position = '|';
+
+    parsePosition(): Position {
+        let position: Position = '|';
         // Is there a position indicator?
         if (this.nextIs('<')) {
             position = '<';
             this.read();
-        }
-        else if (this.nextIs('>')) {
+        } else if (this.nextIs('>')) {
             position = '>';
             this.read();
         }
+
         return position;
     }
-    parseQuote() {
-        const blocks = [];
+
+    parseQuote(): QuoteNode {
+        const blocks: BlockNode[] = [];
+
         // Parse the ", then any whitespace, then the newline
         this.read();
+
         // Then read any whitespace after the quote
         this.readWhitespace();
+
         // Then read the newline.
         this.read();
+
         while (this.more() && !this.nextIs('"')) {
             // Read a block
             const block = this.parseBlock();
             // Add it to the list if we parsed something.
-            if (block !== null)
-                blocks.push(block);
+            if (block !== null) blocks.push(block);
             // Read whitespace until we find the next thing.
-            while (this.nextIsWhitespace())
-                this.read();
+            while (this.nextIsWhitespace()) this.read();
         }
+
         // Read the closing " and the whitespace that follows.
         this.read();
+
         // Is there a position indicator?
         const position = this.parsePosition();
+
         // Read any whitespace after the position indicator.
         this.readWhitespace();
+
         // Read the credit.
         const credit = this.nextIs('\n') ? undefined : this.parseFormat();
+
         return new QuoteNode(blocks, credit, position);
     }
-    parseCallout() {
-        const blocks = [];
+
+    parseCallout(): CalloutNode {
+        const blocks: BlockNode[] = [];
+
         // Parse the = ...
         this.read();
+
         // ...then any whitespace
         this.readWhitespace();
+
         // ...then read the newline.
         this.read();
+
         // Then, read until we find a closing _
         while (this.more() && !this.nextIs('=')) {
             // Read a block
             const block = this.parseBlock();
             // Add it to the list if we parsed something.
-            if (block !== null)
-                blocks.push(block);
+            if (block !== null) blocks.push(block);
             // Read whitespace until we find the next thing.
-            while (this.peek() === ' ' ||
+            while (
+                this.peek() === ' ' ||
                 this.peek() === '\t' ||
-                this.peek() === '\n')
+                this.peek() === '\n'
+            )
                 this.read();
         }
+
         // Read the closing =
         this.read();
+
         // Is there a position indicator?
         const position = this.parsePosition();
+
         // Read whitespace that follows.
         this.readWhitespace();
+
         return new CalloutNode(blocks, position);
     }
-    parseTable() {
-        const rows = [];
+
+    parseTable(): TableNode {
+        const rows: FormatNode[][] = [];
+
         // Parse rows until the lines stop starting with ,
         while (this.more() && this.nextIs(',')) {
             let row = [];
+
             while (this.more() && !this.nextIs('\n')) {
                 // Read the starting , or next |
                 this.read();
+
                 // Read whitespace that follows.
                 this.readWhitespace();
+
                 // Read content until reaching another | or the end of the line.
                 row.push(this.parseFormat('|'));
             }
+
             // Add the row.
             rows.push(row);
+
             // Read the newline
             this.read();
         }
+
         // Read the position indicator if there is one.
         const position = this.parsePosition();
+
         // Read the caption. Note that parsing inline content stops at a newline,
         // so if there's a line break after the last row, there won't be a caption.
         const caption = this.parseFormat();
+
         // Return the new table.
         return new TableNode(rows, position, caption);
     }
+
     // The "awaiting" argument keeps track of upstream formatting. We don't need a stack here
     // because we don't allow infinite nesting of the same formatting type.
-    parseFormat(awaiting) {
-        const segments = [];
+    parseFormat(awaiting?: string): FormatNode {
+        const segments: FormatNodeSegmentType[] = [];
+
         // Read until hitting a delimiter.
         while (this.more() && !this.nextIs('\n')) {
             const next = this.peek();
             const charAfterNext = this.charAfterNext();
+
             // Parse some bold, italic, subscript, superscript
             if (next === '_' || next === '*' || next === '^')
                 segments.push(this.parseStyle(next));
             // Parse unformatted text
-            else if (this.nextIs('`'))
-                segments.push(this.parseInlineCode());
+            else if (this.nextIs('`')) segments.push(this.parseInlineCode());
             // Parse a citation list
-            else if (this.nextIs('<'))
-                segments.push(this.parseCitations());
+            else if (this.nextIs('<')) segments.push(this.parseCitations());
             // Parse a footnote
-            else if (this.nextIs('{'))
-                segments.push(this.parseFootnote());
+            else if (this.nextIs('{')) segments.push(this.parseFootnote());
             // Parse a definition
-            else if (this.nextIs('~'))
-                segments.push(this.parseDefinition());
+            else if (this.nextIs('~')) segments.push(this.parseDefinition());
             // Parse an escaped character
-            else if (this.nextIs('\\'))
-                segments.push(this.parseEscaped());
+            else if (this.nextIs('\\')) segments.push(this.parseEscaped());
             // Parse a link
-            else if (this.nextIs('['))
-                segments.push(this.parseLink());
+            else if (this.nextIs('[')) segments.push(this.parseLink());
             // Parse inline comments
             else if (this.charBeforeNext() === ' ' && this.nextIs('%'))
                 segments.push(this.parseComment());
@@ -610,53 +738,70 @@ export default class Parser {
                     symbol = symbol + this.read();
                     next = this.peek();
                 }
-                segments.push(new ErrorNode(undefined, "Couldn't find symbol @" + symbol));
+                segments.push(
+                    new ErrorNode(undefined, "Couldn't find symbol @" + symbol)
+                );
             }
             // Parse a label
-            else if (next === ':' &&
+            else if (
+                next === ':' &&
                 charAfterNext !== null &&
-                charAfterNext.match(/[a-z]/i)) {
+                charAfterNext.match(/[a-z]/i)
+            ) {
                 segments.push(this.parseLabel());
             }
             // Keep reading text until finding a delimiter.
             else {
                 let text = '';
-                while (this.more() &&
+                while (
+                    this.more() &&
                     (!awaiting || !this.nextIs(awaiting)) &&
                     !this.nextIsContentDelimiter() &&
-                    !this.nextIs('\n'))
+                    !this.nextIs('\n')
+                )
                     text = text + this.read();
                 segments.push(new TextNode(text));
             }
+
             // If we've reached a delimiter we're waiting for, then stop parsing, so it can handle it. Otherwise, we'll keep reading.
-            if (this.peek() === awaiting)
-                break;
+            if (this.peek() === awaiting) break;
         }
+
         return new FormatNode('', segments);
     }
-    parseEmbed() {
+
+    parseEmbed(): EmbedNode {
         // Read |
         this.read();
+
         // Read the URL
         const url = this.readUntilNewlineOr('|');
+
         let description;
         let caption;
         let credit;
+
         if (this.peek() === '|') {
             // Read a |
             this.read();
+
             // Read the description
             description = this.readUntilNewlineOr('|');
+
             if (this.peek() === '|') {
                 // Read a |
                 this.read();
+
                 // Parse the caption
                 caption = this.parseFormat('|');
+
                 if (this.peek() === '|') {
                     // Read a |
                     this.read();
+
                     // Parse the credit
                     credit = this.parseFormat('|');
+
                     // Check for the closing delimeter
                     if (this.peek() === '|')
                         // Read a |
@@ -664,23 +809,30 @@ export default class Parser {
                 }
             }
         }
+
         // Is there a position indicator?
         const position = this.parsePosition();
+
         return new EmbedNode(url, description ?? '', caption, credit, position);
     }
-    parseComment() {
+
+    parseComment(): CommentNode {
         // Consume the opening %
         this.read();
+
         // Consume everything until the next %.
         const comment = this.parseFormat('%');
+
         // Consume the closing %, if we didn't reach the end of input or a newline.
-        if (this.peek() === '%')
-            this.read();
+        if (this.peek() === '%') this.read();
+
         return new CommentNode(comment);
     }
-    parseLabel() {
+
+    parseLabel(): LabelNode | ErrorNode {
         // Consume the :
         this.read();
+
         // Consume everything until it's not a letter.
         let id = '';
         let next = this.peek();
@@ -688,29 +840,36 @@ export default class Parser {
             id = id + this.read();
             next = this.peek();
         }
+
         return new LabelNode(id);
     }
-    parseStyle(awaiting) {
+
+    parseStyle(awaiting: string): FormatNode | ErrorNode {
         // Remember what we're matching.
         const delimeter = this.read();
         let subscript = false;
-        const segments = [];
+        const segments: Array<FormatNode | TextNode | ErrorNode> = [];
         let text = '';
+
         // Special case subscript, which has an extra delimeter.
         if (delimeter === '^' && this.peek() === 'v') {
             this.read();
             subscript = true;
         }
+
         if (delimeter === null)
-            return new ErrorNode(undefined, 'Somehow parsing formatted text at end of file.');
+            return new ErrorNode(
+                undefined,
+                'Somehow parsing formatted text at end of file.'
+            );
+
         // Read some content until reaching the delimiter or the end of the line
         while (this.more() && this.peek() !== delimeter && !this.nextIs('\n')) {
             // If this is more formatted text, make a text node with whatever we've accumulated so far,
             // then parse the formatted text, then reset the accumulator.
             if (this.nextIsContentDelimiter()) {
                 // If the text is a non-empty string, make a text node with what we've accumulated.
-                if (text !== '')
-                    segments.push(new TextNode(text));
+                if (text !== '') segments.push(new TextNode(text));
                 // Parse the formatted content.
                 segments.push(this.parseFormat(awaiting));
                 // Reset the accumulator.
@@ -721,20 +880,25 @@ export default class Parser {
                 text = text + this.read();
             }
         }
+
         // If there's more text, save it!
-        if (text !== '')
-            segments.push(new TextNode(text));
+        if (text !== '') segments.push(new TextNode(text));
+
         // Read the closing delimeter
-        if (this.nextIs(delimeter))
-            this.read();
+        if (this.nextIs(delimeter)) this.read();
         // If it wasn't closed, add an error
-        else
-            segments.push(new ErrorNode(undefined, 'Unclosed ' + delimeter));
-        return new FormatNode(subscript ? 'v' : delimeter, segments);
-    }
-    parseInlineCode() {
+        else segments.push(new ErrorNode(undefined, 'Unclosed ' + delimeter));
+
+        return new FormatNode(
+            subscript ? 'v' : (delimeter as Format),
+            segments
+        );
+    }
+
+    parseInlineCode(): InlineCodeNode {
         // Parse the back tick
         this.read();
+
         // Read until we encounter a closing back tick.
         let code = '';
         while (this.more() && !this.nextIs('`')) {
@@ -747,9 +911,10 @@ export default class Parser {
             }
             code = code + next;
         }
+
         // Read the backtick.
-        if (this.nextIs('`'))
-            this.read();
+        if (this.nextIs('`')) this.read();
+
         // If there's a letter immediately after a backtick, it's a language for an inline code name
         let language = '';
         let next = this.peek();
@@ -758,42 +923,52 @@ export default class Parser {
                 language = language + this.read();
                 next = this.peek();
             } while (next !== null && /^[a-z]$/.test(next));
-        }
-        else
-            language = 'plaintext';
+        } else language = 'plaintext';
+
         return new InlineCodeNode(new TextNode(code), language);
     }
-    parseCitations() {
+
+    parseCitations(): CitationsNode {
         let citations = '';
+
         // Read the <
         this.read();
         // Read the citations.
         citations = this.readUntilNewlineOr('>');
-        if (this.peek() === '>')
-            this.read();
+        if (this.peek() === '>') this.read();
+
         // Trim any whitespace, then split by commas, then remove any empty IDs.
         const citationList = citations
             .split(',')
             .map((citation) => citation.trim())
             .filter((citationID) => citationID.length > 0);
+
         return new CitationsNode(citationList);
     }
-    parseFootnote() {
+
+    parseFootnote(): FootnoteNode {
         // Read the {
         this.read();
+
         // Read the footnote content.
         const footnote = this.parseFormat('}');
+
         // Read the closing }
         this.read();
+
         return new FootnoteNode(footnote);
     }
-    parseDefinition() {
+
+    parseDefinition(): DefinitionNode {
         // Read the ~
         this.read();
+
         // Read the phrase
         const text = this.readUntilNewlineOr('~');
+
         // Read the closing ~
         this.read();
+
         // Read the glossary entry ID
         let glossaryID = '';
         // Stop at the end of the name or file.
@@ -802,37 +977,47 @@ export default class Parser {
             glossaryID = glossaryID + this.read();
             next = this.peek();
         }
+
         return new DefinitionNode(new TextNode(text), glossaryID);
     }
-    parseEscaped() {
+
+    parseEscaped(): TextNode | ErrorNode {
         // Skip the scape and just add the next character.
         this.read();
         const char = this.read();
-        if (char)
-            return new TextNode(char);
+        if (char) return new TextNode(char);
+
         return new ErrorNode(undefined, 'Unterminated escape.');
     }
-    parseLink() {
+
+    parseLink(): LinkNode | ErrorNode {
         // Read the [
         this.read();
+
         // Read pure text until funding |
         const text = this.readUntilNewlineOr('|');
+
         // Catch missing bars
         if (this.peek() !== '|') {
             this.readUntilNewLine();
             return new ErrorNode(undefined, "Missing '|' in link");
         }
+
         // Read the |
         this.read();
+
         // Read the link
         let url = this.readUntilNewlineOr(']');
+
         // Catch missing closing
         if (this.peek() !== ']') {
             this.readUntilNewLine();
             return new ErrorNode(undefined, 'Missing ] in link');
         }
+
         // Read the ]
         this.read();
+
         return new LinkNode(new TextNode(text), url);
     }
 }