bookish-press 0.4.0

package/models/chapter/BlocksNode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/models/chapter/BlocksNode.test.js

@@ -0,0 +1,302 @@
+import { test, expect } from 'vitest';
+import CalloutNode from "./CalloutNode";
+import ChapterNode from "./ChapterNode";
+import CodeNode from "./CodeNode";
+import EmbedNode from "./EmbedNode";
+import FootnoteNode from "./FootnoteNode";
+import FormatNode from "./FormatNode";
+import ListNode from "./ListNode";
+import ParagraphNode from "./ParagraphNode";
+import Parser from './Parser';
+import QuoteNode from "./QuoteNode";
+import RuleNode from "./RuleNode";
+import TableNode from "./TableNode";
+import TextNode from "./TextNode";
+const firstText = "First paragraph.";
+const firstTextNode = new TextNode(firstText);
+const firstFormat = new FormatNode("", [firstTextNode]);
+const firstParagraph = new ParagraphNode(0, firstFormat);
+const lastText = "Last paragraph.";
+const lastTextNode = new TextNode(lastText);
+const lastFormat = new FormatNode("", [lastTextNode]);
+const lastParagraph = new ParagraphNode(0, lastFormat);
+const footnoteText = new TextNode("This is my footnote.");
+const footnote = new FootnoteNode(new FormatNode("", [footnoteText]));
+const paragraphChapter = new ChapterNode([firstParagraph, lastParagraph]);
+const numberedList = new ListNode([firstFormat, lastFormat], true);
+const bulletedList = new ListNode([firstFormat.copy(), lastFormat.copy()], false);
+const beforeBold = new TextNode("I am a ");
+const bold = new TextNode("bold");
+const afterBold = new TextNode(" word.");
+const boldChapter = new ChapterNode([new ParagraphNode(0, new FormatNode("", [beforeBold, new FormatNode("*", [bold]), afterBold]))]);
+test("Insert a block", () => {
+    expect(paragraphChapter.withBlockInserted(firstParagraph, new RuleNode(), true)?.toBookdown()).toBe(`\n\n-\n\n${firstText}\n\n${lastText}`);
+    expect(paragraphChapter.withBlockInserted(firstParagraph, new RuleNode(), false)?.toBookdown()).toBe(`${firstText}\n\n-\n\n${lastText}`);
+    expect(paragraphChapter.withBlockInserted(lastParagraph, new RuleNode(), false)?.toBookdown()).toBe(`${firstText}\n\n${lastText}\n\n-\n\n`);
+});
+test("Remove a block", () => {
+    expect(paragraphChapter.withoutBlock(firstParagraph)?.toBookdown()).toBe(lastText);
+});
+test("Merge adjascent lists", () => {
+    expect(new ChapterNode([numberedList, bulletedList]).toBookdown()).toBe(`\n\n1. ${firstText}\n2. ${lastText}\n\n\n\n* ${firstText}\n* ${lastText}\n\n`);
+    expect(new ChapterNode([numberedList, numberedList]).toBookdown()).toBe(`\n\n1. ${firstText}\n2. ${lastText}\n3. ${firstText}\n4. ${lastText}\n\n`);
+    expect(new ChapterNode([bulletedList, bulletedList]).toBookdown()).toBe(`\n\n* ${firstText}\n* ${lastText}\n* ${firstText}\n* ${lastText}\n\n`);
+});
+test("Format range", () => {
+    // Bold part of a paragraph.
+    expect(paragraphChapter.withRangeFormatted({ start: { node: firstTextNode, index: 6 }, end: { node: firstTextNode, index: 10 } }, "*")?.root.toBookdown())
+        .toBe(`First *para*graph.\n\n${lastText}`);
+    // Remove part of a paragraph.
+    expect(paragraphChapter.withRangeFormatted({ start: { node: firstTextNode, index: 6 }, end: { node: firstTextNode, index: 10 } }, undefined)?.root.toBookdown())
+        .toBe(`First graph.\n\n${lastText}`);
+    // Unbold the bold part of a paragraph with the selection outside the bold.
+    expect(boldChapter.withRangeFormatted({ start: { node: beforeBold, index: beforeBold.getLength() }, end: { node: afterBold, index: 0 } }, "")?.root.toBookdown())
+        .toBe(`I am a bold word.`);
+    // Unbold the bold part of a paragraph with the selection inside the bold.
+    expect(boldChapter.withRangeFormatted({ start: { node: bold, index: 0 }, end: { node: bold, index: bold.getLength() } }, "")?.root.toBookdown())
+        .toBe(`I am a bold word.`);
+    // Expand the bold part of a paragraph.
+    expect(boldChapter.withRangeFormatted({ start: { node: beforeBold, index: beforeBold.getLength() - 2 }, end: { node: afterBold, index: 0 } }, "*")?.root.toBookdown())
+        .toBe(`I am *a bold* word.`);
+    // Delete across a paragraph boundary.
+    expect(paragraphChapter.withoutRange({ start: { node: firstTextNode, index: 6 }, end: { node: lastTextNode, index: 5 } })?.root.toBookdown())
+        .toBe(`First paragraph.`);
+    // Bold across a paragraph boundary.
+    expect(paragraphChapter.withRangeFormatted({ start: { node: firstTextNode, index: 6 }, end: { node: lastTextNode, index: 4 } }, "*")?.root.toBookdown())
+        .toBe(`First *paragraph.*\n\n*Last* paragraph.`);
+});
+test("Split selection", () => {
+    const caret = { node: firstTextNode, index: 5 };
+    const chapter = new ChapterNode([firstParagraph]);
+    // Split a paragraph
+    const split = chapter.withSelectionSplit({ start: caret, end: caret });
+    expect(split?.root.toBookdown()).toBe("First\n\n paragraph.");
+    expect(split?.range.start.node.toBookdown()).toBe(" paragraph.");
+    expect(split?.range.start.index).toBe(0);
+    // Delete a selection and then split
+    const selectSplit = chapter.withSelectionSplit({ start: { node: firstTextNode, index: 5 }, end: { node: firstTextNode, index: 10 } });
+    expect(selectSplit?.root.toBookdown()).toBe("First\n\ngraph.");
+    // Split at the beginning
+    const startCaret = { node: firstTextNode, index: 0 };
+    const startSplit = chapter.withSelectionSplit({ start: startCaret, end: startCaret });
+    expect(startSplit?.root.toBookdown()).toBe(`\n\n${firstText}`);
+    // Split at the end
+    const endCaret = { node: firstTextNode, index: 16 };
+    const endSplit = chapter.withSelectionSplit({ start: endCaret, end: endCaret });
+    expect(endSplit?.root.toBookdown()).toBe(`${firstText}\n\n`);
+});
+test("Without atom", () => {
+    const chapterAtomEnd = new ChapterNode([new ParagraphNode(0, new FormatNode("", [firstFormat, footnote]))]);
+    expect(chapterAtomEnd.withoutAtom(footnote)?.root.toBookdown())
+        .toBe(`${firstText}`);
+    const chapterAtomBegin = new ChapterNode([new ParagraphNode(0, new FormatNode("", [footnote, firstFormat]))]);
+    expect(chapterAtomBegin.withoutAtom(footnote)?.root.toBookdown())
+        .toBe(`${firstText}`);
+    const chapterAtomMiddle = new ChapterNode([new ParagraphNode(0, new FormatNode("", [firstFormat, footnote, lastFormat]))]);
+    expect(chapterAtomMiddle.withoutAtom(footnote)?.root.toBookdown())
+        .toBe(`${firstText}${lastText}`);
+});
+test("Insert atom", () => {
+    const endOfFirst = { node: firstTextNode, index: firstTextNode.getLength() };
+    // Insert empty footnote
+    expect(paragraphChapter.withSegmentAtSelection({ start: endOfFirst, end: endOfFirst }, text => new FootnoteNode(new FormatNode("", [new TextNode(text)])))?.root.toBookdown())
+        .toBe(`${firstText}{}\n\n${lastText}`);
+    // Convert selection to footnote
+    expect(paragraphChapter.withSegmentAtSelection({ start: { node: firstTextNode, index: 6 }, end: { node: firstTextNode, index: 15 } }, text => new FootnoteNode(new FormatNode("", [new TextNode(text)])))?.root.toBookdown())
+        .toBe(`First {paragraph}.\n\n${lastText}`);
+});
+test("Convert paragraphs to lists", () => {
+    // Convert a single paragraph to a list item.
+    expect(paragraphChapter.withParagraphsAsLists({ start: { node: firstTextNode, index: 0 }, end: { node: firstTextNode, index: 0 } }, false)?.toBookdown())
+        .toBe(`\n\n* ${firstText}\n\n${lastText}`);
+    // Convert two paragraphs to a single list
+    expect(paragraphChapter.withParagraphsAsLists({ start: { node: firstTextNode, index: 0 }, end: { node: lastTextNode, index: 0 } }, true)?.toBookdown())
+        .toBe(`\n\n1. ${firstText}\n2. ${lastText}\n\n`);
+    // Convert paragraphs that span a blocks boundary to separate lists.
+    expect(new ChapterNode([firstParagraph, new CalloutNode([lastParagraph])]).withParagraphsAsLists({ start: { node: firstTextNode, index: 0 }, end: { node: lastTextNode, index: 0 } }, true)?.toBookdown())
+        .toBe(`\n\n1. ${firstText}\n\n\n\n=\n\n\n1. ${lastText}\n\n\n=\n\n`);
+    // Convert non-paragraphs to lists
+    expect(new ChapterNode([numberedList]).withParagraphsAsLists({ start: { node: firstTextNode, index: 0 }, end: { node: lastTextNode, index: 0 } }, true))
+        .toBeUndefined();
+});
+test("Convert lists to paragraphs", () => {
+    // Convert lists to paragraphs
+    expect(new ChapterNode([numberedList]).withListsAsParagraphs({ start: { node: firstTextNode, index: 0 }, end: { node: firstTextNode, index: 5 } })?.toBookdown())
+        .toBe(`\n\n${firstText}\n\n${lastText}\n\n`);
+    // Convert both items to paragraphs.
+    expect(new ChapterNode([numberedList]).withListsAsParagraphs({ start: { node: firstTextNode, index: 0 }, end: { node: lastTextNode, index: 5 } })?.toBookdown())
+        .toBe(`\n\n${firstText}\n\n${lastText}\n\n`);
+    // Convert non-list to paragraphs.
+    expect(paragraphChapter.withListsAsParagraphs({ start: { node: firstTextNode, index: 0 }, end: { node: lastTextNode, index: 5 } })?.toBookdown())
+        .toBeUndefined();
+    // Convert two contiguous lists to paragraphs.
+    expect(new ChapterNode([numberedList, bulletedList]).withListsAsParagraphs({ start: { node: firstTextNode, index: 0 }, end: { node: bulletedList.getFirstItem()?.getFirstTextNode(), index: 0 } })?.toBookdown())
+        .toBe(`\n\n${firstText}\n\n${lastText}\n\n\n\n${firstText}\n\n${lastText}\n\n`);
+    // Convert two non-contiguous lists to paragraphs.
+    expect(new ChapterNode([numberedList, new ParagraphNode(0, new FormatNode("", [new TextNode("Intruder!")])), bulletedList]).withListsAsParagraphs({ start: { node: firstTextNode, index: 0 }, end: { node: bulletedList.getFirstItem()?.getFirstTextNode(), index: 0 } })?.toBookdown())
+        .toBe(`\n\n${firstText}\n\n${lastText}\n\nIntruder!\n\n${firstText}\n\n${lastText}\n\n`);
+    // Convert various subparts of a nested list into paragraphs.
+    const oneText = new TextNode("one");
+    const twoText = new TextNode("two");
+    const threeText = new TextNode("three");
+    const fourText = new TextNode("four");
+    const list = new ListNode([new FormatNode("", [oneText]), new ListNode([new FormatNode("", [twoText]), new FormatNode("", [threeText])], true), new FormatNode("", [fourText])], true);
+    expect(new ChapterNode([list]).withListsAsParagraphs({ start: { node: oneText, index: 0 }, end: { node: fourText, index: 0 } })?.toBookdown())
+        .toBe(`\n\n${oneText.getText()}\n\n${twoText.getText()}\n\n${threeText.getText()}\n\n${fourText.getText()}\n\n`);
+    expect(new ChapterNode([list]).withListsAsParagraphs({ start: { node: oneText, index: 0 }, end: { node: twoText, index: 0 } })?.toBookdown())
+        .toBe(`\n\n${oneText.getText()}\n\n${twoText.getText()}\n\n${threeText.getText()}\n\n${fourText.getText()}\n\n`);
+    expect(new ChapterNode([list]).withListsAsParagraphs({ start: { node: twoText, index: 0 }, end: { node: threeText, index: 0 } })?.toBookdown())
+        .toBe(`\n\n${oneText.getText()}\n\n${twoText.getText()}\n\n${threeText.getText()}\n\n${fourText.getText()}\n\n`);
+});
+test("Indent/unindent list items", () => {
+    expect(new ChapterNode([numberedList]).withListsIndented({ start: { node: firstTextNode, index: 0 }, end: { node: firstTextNode, index: 0 } }, true)?.toBookdown()).toBe("\n\n1.. First paragraph.\n2. Last paragraph.\n\n");
+    const indented = new ChapterNode([numberedList]).withListsIndented({ start: { node: firstTextNode, index: 0 }, end: { node: lastTextNode, index: 0 } }, true);
+    expect(indented?.toBookdown()).toBe("\n\n1.. First paragraph.\n2.. Last paragraph.\n\n");
+    expect(indented?.withListsIndented({ start: { node: firstTextNode, index: 0 }, end: { node: lastTextNode, index: 0 } }, false)?.toBookdown()).toBe("\n\n1. First paragraph.\n2. Last paragraph.\n\n");
+});
+test("Style lists", () => {
+    expect(new ChapterNode([numberedList]).withListAsStyle(numberedList, false)?.toBookdown())
+        .toBe(`\n\n* ${firstText}\n* ${lastText}\n\n`);
+});
+test("Backspace/delete", () => {
+    const chapter = new ChapterNode([firstParagraph, lastParagraph]);
+    expect(chapter.withoutAdjacentContent({ node: lastTextNode, index: 1 }, true)?.root.toBookdown())
+        .toBe(`${firstText}\n\nLst paragraph.`);
+    expect(chapter.withoutAdjacentContent({ node: lastTextNode, index: 1 }, false)?.root.toBookdown())
+        .toBe(`${firstText}\n\nast paragraph.`);
+    expect(chapter.withoutAdjacentContent({ node: lastTextNode, index: 0 }, false)?.root.toBookdown())
+        .toBe(`${firstText}${lastText}`);
+    expect(chapter.withoutAdjacentContent({ node: firstTextNode, index: firstTextNode.getLength() }, true)?.root.toBookdown())
+        .toBe(`${firstText}${lastText}`);
+    expect(chapter.withoutAdjacentContent({ node: firstTextNode, index: 0 }, false)?.root.toBookdown())
+        .toBeUndefined();
+    const beforeText = new TextNode("Before");
+    const beforeParagraph = new ParagraphNode(0, new FormatNode("", [beforeText]));
+    const afterText = new TextNode("After");
+    const afterParagraph = new ParagraphNode(0, new FormatNode("", [afterText]));
+    const listChapter = new ChapterNode([beforeParagraph, numberedList, afterParagraph]);
+    // Do nothing when backspacing at the beginning of a list.
+    expect(listChapter.withoutAdjacentContent({ node: firstTextNode, index: 0 }, false)?.root.toBookdown())
+        .toBeUndefined();
+    // Delete a character in a list
+    expect(listChapter.withoutAdjacentContent({ node: firstTextNode, index: 0 }, true)?.root.toBookdown())
+        .toBe(`Before\n\n1. irst paragraph.\n2. ${lastText}\n\nAfter`);
+    // Can't forward delete into a list
+    expect(listChapter.withoutAdjacentContent({ node: beforeText, index: beforeText.getLength() }, true)?.root.toBookdown())
+        .toBe(`Before${firstText}\n\n1. ${lastText}\n\nAfter`);
+    // Backspace a paragraph into the last list item
+    expect(listChapter.withoutAdjacentContent({ node: afterText, index: 0 }, false)?.root.toBookdown())
+        .toBe(`Before\n\n1. ${firstText}\n2. ${lastText}After\n\n`);
+    // Select two list items for deletion.
+    expect(listChapter.withoutRange({ start: { node: firstTextNode, index: 0 }, end: { node: lastTextNode, index: 5 } })?.root.toBookdown())
+        .toBe(`Before\n\n1. paragraph.\n\nAfter`);
+    // Backspace over a block
+    const quoteChapter = new ChapterNode([new QuoteNode([]), firstParagraph]);
+    expect(quoteChapter.withoutAdjacentContent({ node: firstTextNode, index: 0 }, false)?.root.toBookdown())
+        .toBe(`\n\n${firstText}`);
+});
+test("Copy/paste", () => {
+    // Build a document with everything.
+    const sentence1 = new TextNode("Hello, I am a sentence.");
+    const paragraph1 = new ParagraphNode(0, new FormatNode("", [sentence1]));
+    const sentence2 = new TextNode("Hello, I am another sentence.");
+    const boldSentence3 = new TextNode(" Can you believe my size?");
+    const paragraph2 = new ParagraphNode(0, new FormatNode("", [sentence2, new FormatNode("*", [boldSentence3])]));
+    const sentence3 = new TextNode("Lonely last.");
+    const paragraph3 = new ParagraphNode(0, new FormatNode("", [sentence3]));
+    const imageCaption = new TextNode("no image");
+    const imageCredit = new TextNode("Amy");
+    const image = new EmbedNode("nope", "nothing", new FormatNode("", [imageCaption]), new FormatNode("", [imageCredit]));
+    const js = new TextNode("let a = 1;");
+    const code = new CodeNode(js, "js", "|", new FormatNode("", [new TextNode("assignment")]));
+    const item1 = new TextNode("one");
+    const item1a = new TextNode("one a");
+    const item2 = new TextNode("two");
+    const item3 = new TextNode("three");
+    const list = new ListNode([new FormatNode("", [item1]), new ListNode([new FormatNode("", [item1a])], true), new FormatNode("", [item2]), new FormatNode("", [item3])], true);
+    const afterList = new TextNode("Post-list");
+    const afterListParagraph = new ParagraphNode(0, new FormatNode("", [afterList]));
+    const cellr1c1 = new TextNode("a");
+    const cellr1c2 = new TextNode("b");
+    const cellr1c3 = new TextNode("c");
+    const cellr2c1 = new TextNode("d");
+    const cellr2c2 = new TextNode("e");
+    const cellr2c3 = new TextNode("f");
+    const cellr3c1 = new TextNode("g");
+    const cellr3c2 = new TextNode("h");
+    const cellr3c3 = new TextNode("i");
+    const table = new TableNode([
+        [new FormatNode("", [cellr1c1]), new FormatNode("", [cellr1c2]), new FormatNode("", [cellr1c3])],
+        [new FormatNode("", [cellr2c1]), new FormatNode("", [cellr2c2]), new FormatNode("", [cellr2c3])],
+        [new FormatNode("", [cellr3c1]), new FormatNode("", [cellr3c2]), new FormatNode("", [cellr3c3])]
+    ]);
+    const calloutOne = new TextNode("one");
+    const calloutTwo = new TextNode("two");
+    const calloutThree = new TextNode("three");
+    const callout = new CalloutNode([new ParagraphNode(0, new FormatNode("", [calloutOne])), new ParagraphNode(0, new FormatNode("", [calloutTwo])), new ParagraphNode(0, new FormatNode("", [calloutThree]))]);
+    const quoteOne = new TextNode("I'm tired");
+    const quoteCredit = new TextNode("Boomy");
+    const quote = new QuoteNode([new ParagraphNode(0, new FormatNode("", [quoteOne]))], new FormatNode("", [quoteCredit]));
+    const chapter = new ChapterNode([paragraph1, paragraph2, paragraph3, image, code, list, afterListParagraph, table, callout, quote]);
+    const partialSegment = chapter.copyRange({ start: { node: sentence1, index: 12 }, end: { node: sentence1, index: 22 } });
+    const reversedPartialSegment = chapter.copyRange({ start: { node: sentence1, index: 22 }, end: { node: sentence1, index: 12 } });
+    const consecutivePartialParagraphs = chapter.copyRange({ start: { node: sentence1, index: 12 }, end: { node: sentence2, index: 5 } });
+    const threeParagraphs = chapter.copyRange({ start: { node: sentence1, index: sentence1.getLength() - 1 }, end: { node: sentence3, index: 6 } });
+    // Paragraphs
+    expect(partialSegment?.toBookdown())
+        .toBe("a sentence");
+    expect(reversedPartialSegment?.toBookdown())
+        .toBe("a sentence");
+    expect(consecutivePartialParagraphs?.toBookdown())
+        .toBe("a sentence.\n\nHello");
+    expect(threeParagraphs?.toBookdown())
+        .toBe(`.\n\n${sentence2.toBookdown()}*${boldSentence3.toBookdown()}*\n\nLonely`);
+    const partialImageCaption = chapter.copyRange({ start: { node: imageCaption, index: 3 }, end: { node: imageCaption, index: 8 } });
+    const partialImageCredit = chapter.copyRange({ start: { node: imageCredit, index: 2 }, end: { node: imageCredit, index: 3 } });
+    const imageCaptionAndCredit = chapter.copyRange({ start: { node: imageCaption, index: 3 }, end: { node: imageCredit, index: 1 } });
+    const paragraphAndImage = chapter.copyRange({ start: { node: sentence3, index: 7 }, end: { node: imageCaption, index: 2 } });
+    // Images
+    expect(partialImageCaption?.toBookdown())
+        .toBe(`image`);
+    expect(partialImageCredit?.toBookdown())
+        .toBe(`y`);
+    expect(imageCaptionAndCredit?.toBookdown())
+        .toBe(`|nope|nothing|no |my|`);
+    expect(paragraphAndImage?.toBookdown())
+        .toBe(`last.\n\n|nope|nothing|no|Amy|\n\n`);
+    const imageAndCode = chapter.copyRange({ start: { node: imageCredit, index: 0 }, end: { node: js, index: 3 } });
+    // Code
+    expect(imageAndCode?.toBookdown())
+        .toBe(`\n\n|nope|nothing|no image|Amy|\n\n\n\n\`js\nlet\n\`\n\n`);
+    const partialList = chapter.copyRange({ start: { node: item1a, index: 4 }, end: { node: item2, index: 1 } });
+    const partialListAndParagraph = chapter.copyRange({ start: { node: item2, index: 0 }, end: { node: afterList, index: 4 } });
+    // Lists
+    expect(partialList?.toBookdown())
+        .toBe(`1.. a\n2. t`);
+    expect(partialListAndParagraph?.toBookdown())
+        .toBe(`\n\n1. two\n2. three\n\nPost`);
+    // Tables
+    const partialTable = chapter.copyRange({ start: { node: cellr2c2, index: 0 }, end: { node: cellr3c2, index: 1 } });
+    const partialTableAndParagraph = chapter.copyRange({ start: { node: afterList, index: 0 }, end: { node: cellr1c2, index: 1 } });
+    expect(partialTable?.toBookdown())
+        .toBe(`,|e|f\n,g|h|\n`);
+    expect(partialTableAndParagraph?.toBookdown())
+        .toBe(`Post-list\n\n,a|b|\n\n\n`);
+    // Callouts
+    const partialCallout = chapter.copyRange({ start: { node: calloutOne, index: 0 }, end: { node: calloutTwo, index: 1 } });
+    const partialTableAndCallout = chapter.copyRange({ start: { node: cellr3c3, index: 0 }, end: { node: calloutTwo, index: 3 } });
+    expect(partialCallout?.toBookdown())
+        .toBe(`=\none\n\nt\n=`);
+    expect(partialTableAndCallout?.toBookdown())
+        .toBe(`\n\n,||i\n\n\n\n\n=\none\n\ntwo\n=\n\n`);
+    // Quote
+    const partialCalloutAndQuote = chapter.copyRange({ start: { node: calloutThree, index: 0 }, end: { node: quoteOne, index: 9 } });
+    expect(partialCalloutAndQuote?.toBookdown())
+        .toBe(`\n\n=\nthree\n=\n\n\n\n"\nI'm tired\n"\n\n`);
+});
+test("to HTML", () => {
+    expect(Parser.parseChapter(undefined, "Hi.\n\nI am paragraphs.").toHTML()).toBe("<p>Hi.</p><p>I am paragraphs.</p>");
+    expect(Parser.parseChapter(undefined, "* I am one\n\n* I am two\n\n* I am three").toHTML()).toBe("<p></p><ul><li>I am one</li><li>I am two</li><li>I am three</li></ul><p></p>");
+    expect(Parser.parseChapter(undefined, "1. I am one\n\n2. I am two\n\n3. I am three").toHTML()).toBe("<p></p><ol><li>I am one</li><li>I am two</li><li>I am three</li></ol><p></p>");
+    expect(Parser.parseChapter(undefined, "|image.jpg|A picture|A caption|A credit|").toHTML()).toBe('<p></p><img src="image.jpg" alt="A picture" /><p></p>');
+});

package/models/chapter/Bookkeeping.d.ts

@@ -0,0 +1,4 @@
+declare type Bookkeeping = {
+    symbols: Record<string, string>;
+};
+export default Bookkeeping;

package/models/chapter/Bookkeeping.js

@@ -0,0 +1 @@
+export {};

package/models/chapter/CalloutNode.d.ts

@@ -0,0 +1,17 @@
+import BlocksNode from "./BlocksNode";
+import type BlockNode from "./BlockNode";
+import type Position from "./Position";
+export default class CalloutNode extends BlocksNode {
+    #private;
+    constructor(elements: BlockNode[], position?: Position);
+    getType(): string;
+    getPosition(): Position;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    getChildren(): BlockNode[];
+    copy(): this;
+    withPosition(position: Position): CalloutNode;
+    withChildReplaced(node: BlockNode, replacement: BlockNode | undefined): this | undefined;
+    create(blocks: BlockNode[]): CalloutNode;
+}

package/models/chapter/CalloutNode.js

@@ -0,0 +1,36 @@
+import BlocksNode from "./BlocksNode";
+export default class CalloutNode extends BlocksNode {
+    #position;
+    constructor(elements, position = "|") {
+        super(elements);
+        this.#position = position;
+    }
+    getType() { return "callout"; }
+    getPosition() { return this.#position; }
+    toText() {
+        return this.getBlocks().map(element => element.toText()).join(" ");
+    }
+    toHTML() {
+        return `<hr/>${super.toHTML()}<hr/>`;
+    }
+    toBookdown() {
+        return "=\n" + this.getBlocks().map(element => element.toBookdown()).join("\n\n") + "\n=" + (this.#position !== "|" ? this.#position : "");
+    }
+    getChildren() { return this.getBlocks(); }
+    copy() {
+        return new CalloutNode(this.getBlocks().map(e => e.copy()), this.#position);
+    }
+    withPosition(position) { return new CalloutNode(this.getBlocks(), position); }
+    withChildReplaced(node, replacement) {
+        const index = this.getBlocks().indexOf(node);
+        if (index < 0)
+            return;
+        const blocks = replacement === undefined ?
+            [...this.getBlocks().slice(0, index), ...this.getBlocks().slice(index + 1)] :
+            [...this.getBlocks().slice(0, index), replacement, ...this.getBlocks().slice(index + 1)];
+        return new CalloutNode(blocks, this.#position);
+    }
+    create(blocks) {
+        return new CalloutNode(blocks, this.#position);
+    }
+}

package/models/chapter/Caret.d.ts

@@ -0,0 +1,21 @@
+import type Node from "./Node";
+import AtomNode from "./AtomNode";
+import TextNode from "./TextNode";
+declare type Caret = {
+    node: TextNode | AtomNode<any>;
+    index: number;
+};
+export default Caret;
+export declare type CaretRange = {
+    start: Caret;
+    end: Caret;
+};
+export declare type IndexRange = {
+    start: number;
+    end: number;
+};
+export declare function getTextAndAtomNodes(node: Node): (AtomNode<any> | TextNode)[];
+export declare function caretToIndex(node: Node, caret: Caret): number | undefined;
+export declare function indexToCaret(node: Node, index: number): Caret | undefined;
+export declare function caretRangeToIndexRange(node: Node, range: CaretRange): IndexRange | undefined;
+export declare function indexRangeToCaretRange(node: Node, range: IndexRange): CaretRange | undefined;

package/models/chapter/Caret.js

@@ -0,0 +1,69 @@
+import AtomNode from "./AtomNode";
+import TextNode from "./TextNode";
+import FormatNode from "./FormatNode";
+export function getTextAndAtomNodes(node) {
+    return node.getNodes().filter(n => n instanceof TextNode || n instanceof AtomNode);
+}
+function getFormatRoots(node) {
+    const roots = [];
+    node.traverse((node, parents) => {
+        if (node instanceof FormatNode && parents.length > 0 && !(parents[parents.length - 1] instanceof FormatNode))
+            roots.push(node);
+    });
+    return roots;
+}
+export function caretToIndex(node, caret) {
+    let roots = getFormatRoots(node);
+    if (roots.length === 0)
+        roots = [node];
+    let currentIndex = 0;
+    for (let n = 0; n < roots.length; n++) {
+        const nodes = getTextAndAtomNodes(roots[n]);
+        for (let i = 0; i < nodes.length; i++) {
+            const t = nodes[i];
+            if (t !== caret.node)
+                currentIndex += t.getCaretPositionCount();
+            else
+                return currentIndex + caret.index;
+        }
+        // Include one for the root.
+        currentIndex++;
+    }
+}
+export function indexToCaret(node, index) {
+    let roots = getFormatRoots(node);
+    if (roots.length === 0)
+        roots = [node];
+    let currentIndex = 0;
+    for (let n = 0; n < roots.length; n++) {
+        const nodes = getTextAndAtomNodes(roots[n]);
+        for (let i = 0; i < nodes.length; i++) {
+            const t = nodes[i];
+            if (index >= currentIndex && index <= currentIndex + t.getCaretPositionCount()) {
+                // Prefer empty nodes to enable zero width formats.
+                if (i < nodes.length - 1) {
+                    const next = nodes[i + 1];
+                    if (next instanceof TextNode && next.getLength() === 0)
+                        return { node: next, index: 0 };
+                }
+                return { node: t, index: index - currentIndex };
+            }
+            currentIndex += t.getCaretPositionCount();
+        }
+        currentIndex++;
+    }
+}
+export function caretRangeToIndexRange(node, range) {
+    const startIndex = caretToIndex(node, range.start);
+    const endIndex = caretToIndex(node, range.end);
+    if (startIndex === undefined || endIndex === undefined)
+        return;
+    return { start: startIndex, end: endIndex };
+}
+export function indexRangeToCaretRange(node, range) {
+    const start = indexToCaret(node, range.start);
+    const end = indexToCaret(node, range.end);
+    if (start === undefined || end === undefined)
+        return;
+    return { start: start, end: end };
+}

package/models/chapter/ChapterNode.d.ts

@@ -0,0 +1,34 @@
+import type Bookkeeping from "./Bookkeeping";
+import type BlockNode from "./BlockNode";
+import ErrorNode from "./ErrorNode";
+import type TextNode from "./TextNode";
+import FootnoteNode from "./FootnoteNode";
+import EmbedNode from "./EmbedNode";
+import ParagraphNode from "./ParagraphNode";
+import type AtomNode from "./AtomNode";
+import LabelNode from "./LabelNode";
+import CommentNode from "./CommentNode";
+import BlocksNode from "./BlocksNode";
+export default class ChapterNode extends BlocksNode {
+    #private;
+    constructor(blocks: BlockNode[], metadata?: Bookkeeping);
+    getType(): string;
+    getChapter(): this;
+    create(blocks: BlockNode[]): BlocksNode;
+    getErrors(): ErrorNode[];
+    getCitations(): Set<string>;
+    getFootnotes(): FootnoteNode[];
+    getHeaders(): ParagraphNode[];
+    getEmbeds(): EmbedNode[];
+    getComments(): CommentNode[];
+    getLabels(): LabelNode[];
+    hasLabel(labelID: string): boolean;
+    getCitationNumber(citationID: string): number | null;
+    toText(): string;
+    toBookdown(): string;
+    getNextTextOrAtom(node: TextNode | AtomNode<any>): TextNode | AtomNode<any> | undefined;
+    getPreviousTextOrAtom(node: TextNode | AtomNode<any>): TextNode | AtomNode<any> | undefined;
+    getChildren(): BlockNode[];
+    withChildReplaced(node: BlockNode, replacement: BlockNode | undefined): this | undefined;
+    copy(): this;
+}

package/models/chapter/ChapterNode.js

@@ -0,0 +1,80 @@
+import ErrorNode from "./ErrorNode";
+import FootnoteNode from "./FootnoteNode";
+import EmbedNode from "./EmbedNode";
+import ParagraphNode from "./ParagraphNode";
+import CitationsNode from "./CitationsNode";
+import LabelNode from "./LabelNode";
+import CommentNode from "./CommentNode";
+import BlocksNode from "./BlocksNode";
+export default class ChapterNode extends BlocksNode {
+    #metadata;
+    constructor(blocks, metadata) {
+        super(blocks);
+        // Content extracted during parsing.
+        this.#metadata = metadata === undefined ? { symbols: {} } : metadata;
+    }
+    getType() { return "chapter"; }
+    getChapter() { return this; }
+    create(blocks) {
+        return new ChapterNode(blocks, this.#metadata);
+    }
+    getErrors() { return this.getNodes().filter(n => n instanceof ErrorNode); }
+    getCitations() {
+        const citations = new Set();
+        this.getNodes().filter(n => n instanceof CitationsNode).forEach(cites => cites.getMeta().forEach(citationID => citations.add(citationID)));
+        return citations;
+    }
+    getFootnotes() { return this.getNodes().filter(n => n instanceof FootnoteNode); }
+    getHeaders() { return this.getNodes().filter(n => n instanceof ParagraphNode && n.getLevel() > 0); }
+    getEmbeds() { return this.getNodes().filter(n => n instanceof EmbedNode); }
+    getComments() { return this.getNodes().filter(n => n instanceof CommentNode); }
+    getLabels() {
+        return this.getNodes().filter(n => n instanceof LabelNode);
+    }
+    hasLabel(labelID) {
+        return this.getLabels().find(label => label.getMeta() === labelID) !== undefined;
+    }
+    getCitationNumber(citationID) {
+        const index = Array.from(this.getCitations()).sort().indexOf(citationID);
+        return index < 0 ? null : index + 1;
+    }
+    toText() {
+        return this.getBlocks().map(block => block.toText()).join(" ");
+    }
+    toBookdown() {
+        // Render the symbols then all the blocks
+        return Object.keys(this.#metadata.symbols).sort().map(name => `@${name}: ${this.#metadata.symbols[name]}\n\n`).join("") +
+            this.getBlocks().map(b => b.toBookdown()).join("\n\n");
+    }
+    getNextTextOrAtom(node) {
+        // Otherwise, find the next text node after this one.
+        const nodes = this.getTextAndAtomNodes();
+        const index = nodes.indexOf(node);
+        return index === undefined ? undefined :
+            index < nodes.length - 1 ? nodes[index + 1] :
+                undefined;
+    }
+    getPreviousTextOrAtom(node) {
+        // Otherwise, find the next text node after this one.
+        const nodes = this.getTextAndAtomNodes();
+        const index = nodes.indexOf(node);
+        return index === undefined ? undefined :
+            index > 0 ? nodes[index - 1] :
+                undefined;
+    }
+    getChildren() { return this.getBlocks(); }
+    withChildReplaced(node, replacement) {
+        const index = this.getBlocks().indexOf(node);
+        /// If we couldn't find the requested node, don't change anything.
+        if (index < 0)
+            return undefined;
+        // Make a new blocks node, assigning and re-parenting the replacement.
+        const blocks = replacement === undefined ?
+            [...this.getBlocks().slice(0, index), ...this.getBlocks().slice(index + 1)] :
+            [...this.getBlocks().slice(0, index), replacement, ...this.getBlocks().slice(index + 1)];
+        return new ChapterNode(blocks, this.#metadata);
+    }
+    copy() {
+        return new ChapterNode(this.getBlocks().map(b => b.copy()), this.#metadata);
+    }
+}

package/models/chapter/CitationsNode.d.ts

@@ -0,0 +1,16 @@
+import AtomNode from "./AtomNode";
+import type Caret from "./Caret";
+import type Node from "./Node";
+export default class CitationsNode extends AtomNode<string[]> {
+    constructor(citations: string[]);
+    getType(): string;
+    getDefaultCaret(): Caret;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getParentOf(): Node | undefined;
+    copy(): this;
+    withMeta(citations: string[]): CitationsNode;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+}

package/models/chapter/CitationsNode.js

@@ -0,0 +1,17 @@
+import AtomNode from "./AtomNode";
+export default class CitationsNode extends AtomNode {
+    constructor(citations) {
+        super(citations);
+    }
+    getType() { return "citations"; }
+    getDefaultCaret() { return { node: this, index: 0 }; }
+    ;
+    toText() { return ""; }
+    toBookdown() { return `<${this.getMeta().join(",")}>`; }
+    toHTML() { return `(${this.getMeta().join(",")})`; }
+    getParentOf() { return undefined; }
+    copy() { return new CitationsNode([...this.getMeta()]); }
+    withMeta(citations) { return new CitationsNode(citations); }
+    withChildReplaced() { return undefined; }
+    withContentInRange() { return this.copy(); }
+}

package/models/chapter/CodeNode.d.ts

@@ -0,0 +1,30 @@
+import type Node from "./Node";
+import type Position from "./Position";
+import FormatNode from "./FormatNode";
+import TextNode from "./TextNode";
+import BlockNode from "./BlockNode";
+import type { CaretRange } from "./Caret";
+export default class CodeNode extends BlockNode {
+    #private;
+    constructor(code: TextNode, language: string, position: Position, caption?: FormatNode);
+    getType(): string;
+    getCodeNode(): TextNode;
+    getCode(): string;
+    getCaption(): FormatNode;
+    getPosition(): Position;
+    getLanguage(): string;
+    isExecutable(): boolean;
+    getFormats(): FormatNode[];
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    getChildren(): (FormatNode | TextNode)[];
+    copy(): this;
+    getParentOf(node: Node): Node | undefined;
+    withChildReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    withPosition(position: Position): CodeNode;
+    withLanguage(language: string): CodeNode;
+    withExecutable(executable: boolean): CodeNode;
+    withCaption(caption: FormatNode): CodeNode;
+    withContentInRange(range: CaretRange): this | undefined;
+}