bookish-press 0.4.0

package/models/chapter/InlineCodeNode.d.ts

@@ -0,0 +1,12 @@
+import MetadataNode from "./MetadataNode";
+import TextNode from "./TextNode";
+export default class InlineCodeNode extends MetadataNode<string> {
+    constructor(code?: TextNode, language?: string);
+    getType(): string;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    copy(): this;
+    withMeta(meta: string): MetadataNode<string>;
+    withText(text: TextNode): MetadataNode<string>;
+}

package/models/chapter/InlineCodeNode.js

@@ -0,0 +1,18 @@
+import MetadataNode from "./MetadataNode";
+import TextNode from "./TextNode";
+export default class InlineCodeNode extends MetadataNode {
+    constructor(code, language = "plaintext") {
+        super(code === undefined ? new TextNode() : code, language);
+    }
+    getType() { return "inline-code"; }
+    toText() {
+        return this.getText().getText();
+    }
+    toHTML() { return `<code>${this.getMeta()}</code>`; }
+    toBookdown() {
+        return "`" + this.getText().toBookdown().replace(/`/g, '\\`') + "`" + (this.getMeta() === "plaintext" ? "" : this.getMeta());
+    }
+    copy() { return new InlineCodeNode(this.getText(), this.getMeta()); }
+    withMeta(meta) { return new InlineCodeNode(this.getText(), meta); }
+    withText(text) { return new InlineCodeNode(text, this.getMeta()); }
+}

package/models/chapter/LabelNode.d.ts

@@ -0,0 +1,17 @@
+import AtomNode from "./AtomNode";
+import type Caret from "./Caret";
+import type FormatNode from "./FormatNode";
+import type Node from "./Node";
+export default class LabelNode extends AtomNode<string> {
+    constructor(newID: string);
+    getType(): string;
+    getDefaultCaret(): Caret;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(format?: FormatNode): string;
+    getParentOf(): Node | undefined;
+    copy(): this;
+    withMeta(newID: string): LabelNode;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+}

package/models/chapter/LabelNode.js

@@ -0,0 +1,22 @@
+import AtomNode from "./AtomNode";
+const ERROR_PLACEHOLDER = "LABELNOIDERROR";
+export default class LabelNode extends AtomNode {
+    constructor(newID) {
+        super(newID === ERROR_PLACEHOLDER ? "" : newID);
+    }
+    getType() { return "label"; }
+    getDefaultCaret() { return { node: this, index: 0 }; }
+    toText() { return ""; }
+    toHTML() { return ""; }
+    toBookdown(format) {
+        const id = this.getMeta();
+        const nextText = format?.getNextTextOrAtom(this)?.toBookdown();
+        // The trailing space after enables parsing. The error placeholder handles invalid empty label IDs.
+        return `:${id === "" ? ERROR_PLACEHOLDER : id}${nextText?.startsWith(" ") ? "" : " "}`;
+    }
+    getParentOf() { return undefined; }
+    copy() { return new LabelNode(this.getMeta()); }
+    withMeta(newID) { return new LabelNode(newID); }
+    withChildReplaced() { return undefined; }
+    withContentInRange() { return this.copy(); }
+}

package/models/chapter/LinkNode.d.ts

@@ -0,0 +1,12 @@
+import MetadataNode from "./MetadataNode";
+import TextNode from "./TextNode";
+export default class LinkNode extends MetadataNode<string> {
+    constructor(text?: TextNode, url?: string);
+    getType(): string;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    copy(): this;
+    withMeta(meta: string): MetadataNode<string>;
+    withText(text: TextNode): MetadataNode<string>;
+}

package/models/chapter/LinkNode.js

@@ -0,0 +1,16 @@
+import MetadataNode from "./MetadataNode";
+import TextNode from "./TextNode";
+export default class LinkNode extends MetadataNode {
+    constructor(text, url = "") {
+        super(text === undefined ? new TextNode() : text, url);
+    }
+    getType() { return "link"; }
+    toText() { return this.getText().toText(); }
+    toHTML() { return `<a href="${this.getMeta()}">${this.getText().toHTML()}</a>`; }
+    toBookdown() { return `[${this.getText().toBookdown()}|${this.getMeta()}]`; }
+    copy() {
+        return new LinkNode(this.getText(), this.getMeta());
+    }
+    withMeta(meta) { return new LinkNode(this.getText(), meta); }
+    withText(text) { return new LinkNode(text, this.getMeta()); }
+}

package/models/chapter/ListNode.d.ts

@@ -0,0 +1,51 @@
+import type Node from "./Node";
+import FormatNode from "./FormatNode";
+import type { Format } from "./FormatNode";
+import type Caret from "./Caret";
+import { type CaretRange } from "./Caret";
+import BlockNode from "./BlockNode";
+import type Edit from "./Edit";
+export declare type ListNodeType = FormatNode | ListNode;
+export default class ListNode extends BlockNode {
+    #private;
+    constructor(items: Array<FormatNode | ListNode>, numbered: boolean);
+    getType(): string;
+    isNumbered(): boolean;
+    isEmpty(): boolean;
+    getItems(): ListNodeType[];
+    getChildren(): ListNodeType[];
+    getListItems(): ListNode[];
+    getLength(): number;
+    getLastItem(): FormatNode | undefined;
+    getFirstItem(): FormatNode | undefined;
+    getFormats(): FormatNode[];
+    getFirstLastItem(first: boolean): FormatNode | undefined;
+    getLevel(root: Node): number;
+    toText(): string;
+    toBookdown(level?: number): string;
+    toHTML(): string;
+    getParentOf(node: Node): Node | undefined;
+    atBeginningOfItem(root: Node, caret: Caret): boolean;
+    getItemContaining(caret: Caret): number | undefined;
+    getItem(index: number): ListNodeType | undefined;
+    getFirstCaret(): Caret | undefined;
+    copy(): this;
+    withStyle(numbered: boolean): ListNode;
+    withItemAppended(item: ListNodeType): ListNode;
+    withItemPrepended(item: ListNodeType): ListNode;
+    withItemAt(item: ListNodeType, index: number): ListNode | undefined;
+    withItemAfter(item: ListNodeType, anchor: ListNodeType): ListNode | undefined;
+    withItemBefore(item: ListNodeType, anchor: ListNodeType): ListNode | undefined;
+    withItemReplaced(index: number, item: ListNodeType): ListNode | undefined;
+    withoutItemAt(index: number): ListNode | undefined;
+    withoutItem(item: FormatNode): ListNode | undefined;
+    withListAppended(list: ListNode): ListNode;
+    withItemMergedBackwards(index: number): [ListNode, Caret] | undefined;
+    withItemSplit(caret: Caret): ListNode | undefined;
+    withItemIndented(format: FormatNode): ListNode | undefined;
+    withItemUnindented(format: FormatNode): ListNode | undefined;
+    withChildReplaced(node: ListNodeType, replacement: ListNodeType | undefined): this | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+    withNodeInserted(caret: Caret, node: Node): Edit;
+    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit;
+}

package/models/chapter/ListNode.js

@@ -0,0 +1,370 @@
+import FormatNode from "./FormatNode";
+import { caretToIndex, indexToCaret } from "./Caret";
+import BlockNode from "./BlockNode";
+export default class ListNode extends BlockNode {
+    #numbered;
+    #items;
+    constructor(items, numbered) {
+        super();
+        this.#numbered = numbered;
+        let adjustedItems = items
+            // Make sure all format nodes have an empty text.
+            .map(i => i instanceof FormatNode ? i.withTextIfEmpty() : i)
+            // Strip all empty sublists.
+            .filter(i => !i.isEmpty());
+        this.#items = adjustedItems;
+    }
+    getType() { return "list"; }
+    isNumbered() { return this.#numbered; }
+    isEmpty() { return this.#items.length === 0 || this.#items.every(i => i instanceof ListNode && i.isEmpty()); }
+    getItems() { return this.#items; }
+    getChildren() { return this.#items; }
+    getListItems() { return this.#items.filter(i => i instanceof ListNode); }
+    getLength() { return this.#items.length; }
+    getLastItem() { return this.getFirstLastItem(false); }
+    getFirstItem() { return this.getFirstLastItem(true); }
+    getFormats() {
+        return this.#items.reduce((previous, current) => previous.concat(current instanceof FormatNode ? [current] : current.getFormats()), []);
+    }
+    getFirstLastItem(first) {
+        if (this.#items.length === 0)
+            return undefined;
+        // If it's a format, return it.
+        const last = this.#items[first ? 0 : this.getLength() - 1];
+        if (last instanceof FormatNode)
+            return last;
+        // Otherwise, recurse into the last item's list.
+        return last.getFirstLastItem(first);
+    }
+    getLevel(root) {
+        const parent = root.getParentOf(this);
+        if (parent instanceof ListNode)
+            return parent.getLevel(root) + 1;
+        else
+            return 1;
+    }
+    toText() {
+        return this.#items.map(item => item.toText()).join(" ");
+    }
+    toBookdown(level = 1) {
+        return this.isNumbered() ?
+            this.#items.map((item, number) => (item instanceof ListNode ? "" : ((number + 1) + ".".repeat(level)) + " ") + item.toBookdown(level + 1)).join("\n") :
+            this.#items.map(item => (item instanceof ListNode ? "" : "*".repeat(level) + " ") + item.toBookdown(level + 1)).join("\n");
+    }
+    toHTML() {
+        return this.isNumbered() ?
+            `<ol>${this.#items.map(i => `<li>${i.toHTML()}</li>`).join("")}</ol>` :
+            `<ul>${this.#items.map(i => `<li>${i.toHTML()}</li>`).join("")}</ul>`;
+    }
+    getParentOf(node) {
+        return this.#items.map(b => b === node ? this : b.getParentOf(node)).find(b => b !== undefined);
+    }
+    atBeginningOfItem(root, caret) {
+        const format = caret.node.getFarthestParentMatching(root, n => n instanceof FormatNode);
+        return format !== undefined &&
+            caret.node.hasAncestor(root, this) &&
+            caret.index === 0 &&
+            format.getTextNodes()[0] === caret.node;
+    }
+    getItemContaining(caret) {
+        const match = this.#items.find(n => n.getParentOf(caret.node) !== undefined);
+        if (match === undefined)
+            return undefined;
+        const index = this.#items.indexOf(match);
+        if (index === undefined)
+            return undefined;
+        return index;
+    }
+    getItem(index) {
+        if (index < 0 || index >= this.#items.length)
+            return;
+        return this.#items[index];
+    }
+    getFirstCaret() { return this.#items.length === 0 ? undefined : this.#items[0].getFirstCaret(); }
+    copy() {
+        return new ListNode(this.#items.map(i => i.copy()), this.#numbered);
+    }
+    withStyle(numbered) {
+        return new ListNode(this.#items, numbered);
+    }
+    withItemAppended(item) {
+        return new ListNode([...this.#items, item], this.#numbered);
+    }
+    withItemPrepended(item) {
+        return new ListNode([item, ...this.#items], this.#numbered);
+    }
+    withItemAt(item, index) {
+        if (index < 0 || index > this.#items.length)
+            return;
+        const newItems = this.#items.slice();
+        newItems.splice(index, 0, item);
+        return new ListNode(newItems, this.#numbered);
+    }
+    withItemAfter(item, anchor) {
+        const index = this.#items.indexOf(anchor);
+        if (index < 0)
+            return;
+        return this.withItemAt(item, index + 1);
+    }
+    withItemBefore(item, anchor) {
+        const index = this.#items.indexOf(anchor);
+        if (index < 0)
+            return;
+        return this.withItemAt(item, index);
+    }
+    withItemReplaced(index, item) {
+        if (index < 0 || index >= this.#items.length)
+            return;
+        const newItems = this.#items.slice();
+        newItems[index] = item;
+        return new ListNode(newItems, this.#numbered);
+    }
+    withoutItemAt(index) {
+        if (index < 0 || index >= this.#items.length)
+            return;
+        const newItems = this.#items.slice();
+        newItems.splice(index, 1);
+        return new ListNode(newItems, this.#numbered);
+    }
+    withoutItem(item) {
+        const index = this.#items.indexOf(item);
+        if (index < 0)
+            return;
+        return this.withoutItemAt(index);
+    }
+    withListAppended(list) {
+        return new ListNode([...this.#items, ...list.#items], this.#numbered);
+    }
+    withItemMergedBackwards(index) {
+        if (index <= 0 || index >= this.#items.length)
+            return;
+        const deletedItem = this.#items[index];
+        let previousItem = this.#items[index - 1];
+        // If we're merging a sublist back into this list, move its
+        // remaining format into the previous item.
+        if (deletedItem instanceof ListNode) {
+            if (previousItem instanceof ListNode)
+                return;
+            const itemToMerge = deletedItem.getFirstItem();
+            if (itemToMerge === undefined)
+                return;
+            const newSubList = deletedItem.withChildReplaced(itemToMerge, undefined);
+            if (newSubList === undefined)
+                return;
+            const listWithRevisedSublist = this.withChildReplaced(deletedItem, newSubList);
+            if (listWithRevisedSublist === undefined)
+                return;
+            const lastCaret = previousItem.getLastCaret();
+            if (lastCaret === undefined)
+                return;
+            const textIndex = caretToIndex(previousItem, lastCaret);
+            if (textIndex === undefined)
+                return;
+            const mergedItem = previousItem.withSegmentsAppended(itemToMerge);
+            const listWithMergedItem = listWithRevisedSublist.withChildReplaced(previousItem, mergedItem);
+            if (listWithMergedItem === undefined)
+                return;
+            const newCaret = indexToCaret(mergedItem, textIndex);
+            if (newCaret === undefined)
+                return;
+            return [listWithMergedItem, newCaret];
+        }
+        // If the previous item is a list, find it's last item.
+        else if (previousItem instanceof ListNode) {
+            const lastItem = previousItem.getLastItem();
+            if (lastItem === undefined)
+                return;
+            const lastCaret = lastItem.getLastCaret();
+            if (lastCaret === undefined)
+                return;
+            const newCaretIndex = caretToIndex(lastItem, lastCaret);
+            if (newCaretIndex === undefined)
+                return;
+            const mergedItem = lastItem.withSegmentsAppended(deletedItem);
+            const newSublist = previousItem.withChildReplaced(lastItem, mergedItem);
+            if (newSublist === undefined)
+                return;
+            const newList = this.withChildReplaced(previousItem, newSublist)?.withoutItemAt(index);
+            if (newList === undefined)
+                return;
+            const newCaret = indexToCaret(mergedItem, newCaretIndex);
+            if (newCaret === undefined)
+                return;
+            return [newList, newCaret];
+        }
+        else {
+            const lastCaret = previousItem.getLastCaret();
+            if (lastCaret === undefined)
+                return;
+            const newCaretIndex = caretToIndex(previousItem, lastCaret);
+            if (newCaretIndex === undefined)
+                return;
+            const mergedItem = previousItem.withSegmentsAppended(deletedItem);
+            const newList = this.withItemReplaced(index - 1, mergedItem)?.withoutItemAt(index);
+            if (newList === undefined)
+                return;
+            const newCaret = indexToCaret(mergedItem, newCaretIndex);
+            if (newCaret === undefined)
+                return;
+            return [newList, newCaret];
+        }
+    }
+    withItemSplit(caret) {
+        // Which item contains the caret?
+        const item = this.#items.find(i => i instanceof FormatNode && i.contains(caret.node));
+        if (item === undefined)
+            return;
+        const parts = item.split(caret);
+        if (parts === undefined)
+            return;
+        const [first, second] = parts;
+        return this.withItemAfter(second, item)?.withItemAfter(first, item)?.withoutItem(item);
+    }
+    // Recursively search for the given item and indent it, constructing a new list.
+    withItemIndented(format) {
+        // Check each item in the list to see if it matches...
+        for (let index = 0; index < this.#items.length; index++) {
+            const item = this.#items[index];
+            // Base case: does this list contain the item?
+            if (item === format) {
+                const beforeList = this.#items[index - 1];
+                const afterList = this.#items[index + 1];
+                // If the format is just after a list, move the format to the end of the list.
+                if (beforeList instanceof ListNode)
+                    return this.withItemReplaced(index - 1, beforeList.withItemAppended(format))?.withoutItemAt(index);
+                // If the format is just before a list, move the format to the beginning of the list.
+                else if (afterList instanceof ListNode)
+                    return this.withItemReplaced(index + 1, afterList.withItemPrepended(format))?.withoutItemAt(index);
+                // Otherwise, make a new sub list node, add the format to it.
+                else
+                    return this.withItemReplaced(index, new ListNode([format], this.#numbered));
+            }
+            // If this is a sublist, see if it contains the item, and if so,
+            // replace this list with list that has the item indented.
+            else if (item instanceof ListNode) {
+                const newList = item.withItemIndented(format);
+                if (newList !== undefined)
+                    return this.withItemReplaced(index, newList);
+            }
+        }
+        // Otherwise, return nothing.
+    }
+    // Recursively search for the item and unindent it, constructing a new list.
+    withItemUnindented(format) {
+        // Check each sublist in the list to see if any has the item so we can unindent it into this.
+        for (let index = 0; index < this.#items.length; index++) {
+            const list = this.#items[index];
+            if (list instanceof ListNode) {
+                const match = list.#items.indexOf(format);
+                // If we found it in this sublist, extract it here!
+                if (match >= 0) {
+                    const before = new ListNode(list.#items.slice(0, match), this.#numbered);
+                    const after = new ListNode(list.#items.slice(match + 1), this.#numbered);
+                    let newItems = this.#items.slice(0, index);
+                    if (before.getLength() > 0)
+                        newItems.push(before);
+                    newItems.push(format);
+                    if (after.getLength() > 0)
+                        newItems.push(after);
+                    newItems = newItems.concat(this.#items.slice(index + 1));
+                    return new ListNode(newItems, this.#numbered);
+                }
+                // If the sublist doesn't have it, see if it's sublist does
+                else {
+                    const unindented = list.withItemUnindented(format);
+                    if (unindented !== undefined)
+                        return this.withItemReplaced(index, unindented);
+                }
+            }
+        }
+        // Otherwise, return nothing, indicating no match.
+    }
+    withChildReplaced(node, replacement) {
+        const index = this.#items.indexOf(node);
+        if (index < 0)
+            return;
+        return new ListNode(replacement === undefined ?
+            [...this.#items.slice(0, index), ...this.#items.slice(index + 1)] :
+            [...this.#items.slice(0, index), replacement, ...this.#items.slice(index + 1)], this.#numbered);
+    }
+    withContentInRange(range) {
+        const containsStart = this.contains(range.start.node);
+        const containsEnd = this.contains(range.end.node);
+        if (!containsStart && !containsEnd)
+            return this.copy();
+        const newItems = [];
+        let foundStart = false;
+        let foundEnd = false;
+        for (let i = 0; i < this.#items.length; i++) {
+            if (this.#items[i].contains(range.start.node))
+                foundStart = true;
+            if (((containsStart && foundStart) || !containsStart) &&
+                ((containsEnd && !foundEnd) || !containsEnd)) {
+                const newItem = this.#items[i].withContentInRange(range);
+                if (newItem === undefined)
+                    return;
+                newItems.push(newItem);
+            }
+            if (this.#items[i].contains(range.end.node))
+                foundEnd = true;
+        }
+        return new ListNode(newItems, this.#numbered);
+    }
+    withNodeInserted(caret, node) {
+        if (!this.contains(caret.node))
+            return;
+        if (!(node instanceof ListNode))
+            return;
+        // Find the anchor item.
+        const anchor = this.#items.find(i => i.contains(caret.node));
+        if (anchor === undefined)
+            return;
+        const items = node.getItems();
+        let lastItem = anchor;
+        let newList = this;
+        while (items.length > 0) {
+            let item = items.shift();
+            if (item === undefined)
+                return;
+            // Insert all of the node's items into this list, merging the first.
+            if (lastItem === anchor) {
+                const edit = anchor.withNodeInserted(caret, item);
+                if (edit === undefined || !(edit.root instanceof FormatNode))
+                    return;
+                item = edit.root;
+                newList = newList.withChildReplaced(anchor, item);
+            }
+            else {
+                newList = newList.withItemAfter(item, lastItem);
+            }
+            if (newList === undefined)
+                return;
+            // Remember where we inserted.
+            lastItem = item;
+        }
+        // The caret should be the last item inserted.
+        const newCaret = lastItem instanceof FormatNode ? lastItem.getLastCaret() : lastItem.getLastItem()?.getLastCaret();
+        if (newCaret === undefined)
+            return;
+        return { root: newList, range: { start: newCaret, end: newCaret } };
+    }
+    withRangeFormatted(range, format) {
+        const sortedRange = this.sortRange(range);
+        const itemStart = this.getItemContaining(sortedRange.start);
+        const itemEnd = this.getItemContaining(sortedRange.end);
+        const edit = super.withRangeFormatted(sortedRange, format);
+        // If we were deleting and two list items were involved, merge them.
+        if (edit && format === undefined && itemStart !== undefined && itemEnd !== undefined && itemStart !== itemEnd) {
+            const newList = edit.root;
+            const itemIndex = itemEnd - (this.#items.length - newList.#items.length);
+            if (itemIndex > 0 && newList.getLength() > 1) {
+                // Merge the items, accounting for the new index of the last item.
+                const mergedEdit = newList.withItemMergedBackwards(itemIndex);
+                if (mergedEdit === undefined)
+                    return;
+                return { root: mergedEdit[0], range: { start: mergedEdit[1], end: mergedEdit[1] } };
+            }
+        }
+        return edit;
+    }
+}

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

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

package/models/chapter/ListNode.test.js

@@ -0,0 +1,49 @@
+import { test, expect } from 'vitest';
+import FormatNode from "./FormatNode";
+import ListNode from "./ListNode";
+import TextNode from "./TextNode";
+const oneText = new TextNode("one");
+const oneFormat = new FormatNode("", [oneText]);
+const twoText = new TextNode("two");
+const twoFormat = new FormatNode("", [twoText]);
+const threeText = new TextNode("three");
+const threeFormat = new FormatNode("", [threeText]);
+const fourText = new TextNode("four");
+const fourFormat = new FormatNode("", [fourText]);
+const fiveText = new TextNode("five");
+const fiveFormat = new FormatNode("", [fiveText]);
+const shortList = new ListNode([oneFormat, twoFormat, threeFormat], false);
+const list = new ListNode([oneFormat, new ListNode([twoFormat, threeFormat, fourFormat], false), fiveFormat], false);
+test("Insert items", () => {
+    expect(shortList.withItemAppended(fourFormat)?.toBookdown()).toBe(`* one\n* two\n* three\n* four`);
+    expect(shortList.withItemPrepended(fourFormat)?.toBookdown()).toBe(`* four\n* one\n* two\n* three`);
+    expect(shortList.withItemAt(fourFormat, 9)).toBeUndefined();
+    expect(shortList.withItemAt(fourFormat, 1)?.toBookdown()).toBe(`* one\n* four\n* two\n* three`);
+    expect(shortList.withItemAfter(fourFormat, oneFormat)?.toBookdown()).toBe(`* one\n* four\n* two\n* three`);
+    expect(shortList.withItemBefore(fourFormat, twoFormat)?.toBookdown()).toBe(`* one\n* four\n* two\n* three`);
+    expect(shortList.withListAppended(new ListNode([fourFormat, fiveFormat], true))?.toBookdown()).toBe(`* one\n* two\n* three\n* four\n* five`);
+});
+test("Remove items", () => {
+    expect(shortList.withItemReplaced(1, fourFormat)?.toBookdown()).toBe(`* one\n* four\n* three`);
+    expect(shortList.withoutItemAt(0)?.toBookdown()).toBe(`* two\n* three`);
+});
+test("Split", () => {
+    expect(shortList.withItemSplit({ node: threeText, index: 2 })?.toBookdown())
+        .toBe("* one\n* two\n* th\n* ree");
+});
+test("Merge", () => {
+    const merged = shortList.withItemMergedBackwards(1);
+    expect(merged).not.toBeUndefined();
+    if (merged !== undefined)
+        expect(merged[0].toBookdown()).toBe("* onetwo\n* three");
+});
+test("Indent", () => {
+    expect(list.withItemIndented(oneFormat)?.toBookdown()).toBe(`** one\n** two\n** three\n** four\n* five`);
+    expect(list.withItemIndented(twoFormat)?.toBookdown()).toBe(`* one\n*** two\n** three\n** four\n* five`);
+    expect(list.withItemIndented(fiveFormat)?.toBookdown()).toBe(`* one\n** two\n** three\n** four\n** five`);
+});
+test("Unindent", () => {
+    expect(list.withItemUnindented(twoFormat)?.toBookdown()).toBe(`* one\n* two\n** three\n** four\n* five`);
+    expect(list.withItemUnindented(oneFormat)?.toBookdown()).toBeUndefined();
+    expect(list.withItemUnindented(threeFormat)?.toBookdown()).toBe(`* one\n** two\n* three\n** four\n* five`);
+});

package/models/chapter/MetadataNode.d.ts

@@ -0,0 +1,17 @@
+import type { CaretRange } from "./Caret";
+import Node from "./Node";
+import type TextNode from "./TextNode";
+export default abstract class MetadataNode<MetaType> extends Node {
+    #private;
+    constructor(text: TextNode, meta: MetaType);
+    getMeta(): MetaType;
+    getText(): TextNode;
+    abstract withMeta(meta: MetaType): MetadataNode<MetaType>;
+    abstract withText(text: TextNode): MetadataNode<MetaType>;
+    abstract toText(): string;
+    abstract toBookdown(): string;
+    getChildren(): TextNode[];
+    getParentOf(node: Node): Node | undefined;
+    withChildReplaced(node: TextNode, replacement: TextNode | undefined): this | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+}

package/models/chapter/MetadataNode.js

@@ -0,0 +1,24 @@
+import Node from "./Node";
+export default class MetadataNode extends Node {
+    #text;
+    #meta;
+    constructor(text, meta) {
+        super();
+        this.#text = text;
+        this.#meta = meta;
+    }
+    getMeta() { return this.#meta; }
+    getText() { return this.#text; }
+    getChildren() { return [this.#text]; }
+    getParentOf(node) { return this.#text === node ? this : undefined; }
+    withChildReplaced(node, replacement) {
+        if (this.#text === node && replacement !== undefined)
+            return this.withText(replacement);
+    }
+    withContentInRange(range) {
+        const selectedText = this.#text.withContentInRange(range);
+        if (selectedText === undefined)
+            return undefined;
+        return this.withText(selectedText);
+    }
+}

package/models/chapter/Node.d.ts

@@ -0,0 +1,36 @@
+import type Caret from "./Caret";
+import type { CaretRange } from "./Caret";
+import type Edit from "./Edit";
+export default abstract class Node {
+    readonly nodeID: number;
+    constructor();
+    abstract toText(): string;
+    abstract toBookdown(): string;
+    abstract toHTML(): string;
+    abstract getType(): string;
+    abstract copy(): this;
+    abstract withChildReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    abstract getChildren(): Node[];
+    abstract getParentOf(node: Node): Node | undefined;
+    getID(): number;
+    traverse(fn: (node: Node, parents: Node[]) => void, parents?: Node[]): void;
+    traverseChildren(fn: (node: Node, parents: Node[]) => void, parents: Node[]): void;
+    getNodes(): Node[];
+    sortRange(range: CaretRange): CaretRange;
+    getNode(id: number): Node | undefined;
+    getIndexOf(node: Node): number | undefined;
+    contains(node: Node): boolean;
+    getParentsOf(node: Node): Node[] | undefined;
+    getParent(root: Node): Node | undefined;
+    hasAncestor(root: Node, node: Node): boolean;
+    getClosestParentOfType<T extends Node>(root: Node, type: Function): T | undefined;
+    isInside(root: Node, type: Function): boolean;
+    getClosestParentMatching(root: Node, match: (node: Node) => boolean): Node | undefined;
+    getFarthestParentMatching(root: Node, match: (node: Node) => boolean): Node | undefined;
+    getAncestors(root: Node): Node[];
+    getCommonAncestor(root: Node, node: Node): Node | undefined;
+    withNodeReplaced(node: Node, replacement: Node | undefined): this | undefined;
+    abstract withContentInRange(range: CaretRange): this | undefined;
+    withNodeInserted(caret: Caret, node: Node): Edit;
+    copyRange(range: CaretRange): Node | undefined;
+}