bookish-press 0.4.0

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

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

package/models/chapter/Parser.test.js

@@ -0,0 +1,25 @@
+import { test, expect } from 'vitest';
+import Parser from "./Parser";
+test("Empty chapter", () => {
+    expect(Parser.parseChapter(undefined, "").toBookdown()).toBe("");
+});
+test("Single paragraph", () => {
+    expect(Parser.parseChapter(undefined, "hello").toBookdown()).toBe("hello");
+});
+test("Peek", () => {
+    const p = new Parser(undefined, "# hello");
+    expect(p.peek()).toBe("#");
+    expect(p.read()).toBe("#");
+    expect(p.peek()).toBe(" ");
+});
+test("More", () => {
+    const p = new Parser(undefined, "#");
+    expect(p.more()).toBe(true);
+    const p2 = new Parser(undefined, "");
+    expect(p2.more()).toBe(false);
+});
+test("Whitespace", () => {
+    const p = new Parser(undefined, "    Hi");
+    p.readWhitespace();
+    expect(p.peek()).toBe("H");
+});

package/models/chapter/Position.d.ts

@@ -0,0 +1,2 @@
+declare type Position = "|" | "<" | ">";
+export default Position;

package/models/chapter/Position.js

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

package/models/chapter/QuoteNode.d.ts

@@ -0,0 +1,25 @@
+import type Node from "./Node";
+import BlockNode from "./BlockNode";
+import type Position from "./Position";
+import FormatNode from "./FormatNode";
+import BlocksNode from "./BlocksNode";
+import type { CaretRange } from "./Caret";
+export default class QuoteNode extends BlocksNode {
+    #private;
+    constructor(elements: BlockNode[], credit?: FormatNode, position?: Position);
+    getType(): string;
+    getCredit(): FormatNode;
+    getPosition(): Position;
+    getFormats(): FormatNode[];
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getChildren(): Node[];
+    getParentOf(node: Node): Node | undefined;
+    copy(): this;
+    create(blocks: BlockNode[]): BlocksNode;
+    withChildReplaced(node: BlockNode | FormatNode, replacement: BlockNode | FormatNode | undefined): this | undefined;
+    withCredit(credit: FormatNode | undefined): QuoteNode;
+    withPosition(position: Position): QuoteNode;
+    withContentInRange(range: CaretRange): this | undefined;
+}

package/models/chapter/QuoteNode.js

@@ -0,0 +1,61 @@
+import BlockNode from "./BlockNode";
+import FormatNode from "./FormatNode";
+import BlocksNode from "./BlocksNode";
+import TextNode from "./TextNode";
+export default class QuoteNode extends BlocksNode {
+    #credit;
+    #position;
+    constructor(elements, credit, position = "|") {
+        super(elements);
+        this.#position = position;
+        this.#credit = credit === undefined ? new FormatNode("", [new TextNode()]) : credit.withTextIfEmpty();
+    }
+    getType() { return "quote"; }
+    getCredit() { return this.#credit; }
+    getPosition() { return this.#position; }
+    getFormats() { return [this.#credit]; }
+    toText() {
+        return this.getBlocks().map(element => element.toText()).join(" ") + (this.#credit ? " " + this.#credit.toText() : "");
+    }
+    toBookdown() {
+        return `"\n${this.getBlocks().map(element => element.toBookdown()).join("\n\n")}\n"${this.#position === "|" ? "" : this.#position}${this.#credit ? this.#credit.toBookdown() : ""}`;
+    }
+    toHTML() { return `"${super.toHTML()}"<center>${this.#credit.toHTML()}</center>`; }
+    getChildren() { return [...this.getBlocks(), this.#credit]; }
+    getParentOf(node) {
+        if (node === this.#credit)
+            return this;
+        const creditParent = this.#credit.getParentOf(node);
+        if (creditParent !== undefined)
+            return creditParent;
+        return super.getParentOf(node);
+    }
+    copy() { return new QuoteNode(this.getBlocks().map(b => b.copy())); }
+    create(blocks) { return new QuoteNode(blocks, this.#credit, this.#position); }
+    withChildReplaced(node, replacement) {
+        // Replace the credit.
+        if (this.#credit === node && (replacement instanceof FormatNode || replacement === undefined))
+            return new QuoteNode(this.getBlocks(), replacement, this.#position);
+        // Replace a block.
+        if (replacement !== undefined && !(replacement instanceof BlockNode))
+            return;
+        const index = this.getBlocks().indexOf(node);
+        if (index < 0)
+            return;
+        // 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 QuoteNode(blocks, this.#credit, this.#position);
+    }
+    withCredit(credit) { return new QuoteNode(this.getBlocks(), credit, this.#position); }
+    withPosition(position) { return new QuoteNode(this.getBlocks(), this.#credit, position); }
+    withContentInRange(range) {
+        // First get the blocks in range.
+        const newQuote = super.withContentInRange(range);
+        if (newQuote === undefined)
+            return;
+        const newCredit = this.getBlocks().find(b => b.contains(range.end.node)) !== undefined ? new FormatNode("", [new TextNode()]) : this.#credit.withContentInRange(range);
+        return newQuote.withNodeReplaced(this.#credit, newCredit);
+    }
+}

package/models/chapter/ReferenceNode.d.ts

@@ -0,0 +1,29 @@
+import Node from "./Node";
+export default class ReferenceNode extends Node {
+    readonly citationID: string;
+    readonly authors: string;
+    readonly year: string;
+    readonly title: string;
+    readonly source: string;
+    readonly url: string;
+    readonly summary: string;
+    readonly short: boolean;
+    constructor(citationID: string, authors?: string, year?: string, title?: string, source?: string, url?: string, summary?: string, short?: boolean);
+    getType(): string;
+    getChildren(): never[];
+    getParentOf(): Node | undefined;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    toList(): string[];
+    copy(): this;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+    withCitationID(id: string): ReferenceNode;
+    withAuthors(authors: string): ReferenceNode;
+    withYear(year: string): ReferenceNode;
+    withTitle(title: string): ReferenceNode;
+    withSource(source: string): ReferenceNode;
+    withURL(url: string): ReferenceNode;
+    withSummary(summary: string): ReferenceNode;
+}

package/models/chapter/ReferenceNode.js

@@ -0,0 +1,48 @@
+import Node from "./Node";
+export default class ReferenceNode extends Node {
+    citationID;
+    authors;
+    year;
+    title;
+    source;
+    url;
+    summary;
+    short;
+    constructor(citationID, authors = "", year = "", title = "", source = "", url = "", summary = "", short = false) {
+        super();
+        this.citationID = citationID;
+        this.authors = authors;
+        this.year = year;
+        this.title = title;
+        this.source = source;
+        this.url = url;
+        this.summary = summary;
+        this.short = short;
+    }
+    getType() { return "reference"; }
+    getChildren() { return []; }
+    getParentOf() { return undefined; }
+    toText() { return this.authors + " " + this.year + " " + this.title + " " + this.source + (this.summary ? this.summary : ""); }
+    toBookdown() { return ""; }
+    toHTML() { return ""; }
+    toList() {
+        const list = [this.authors, this.year, this.title, this.source];
+        if (this.url)
+            list.push(this.url);
+        if (this.summary)
+            list.push(this.summary);
+        return list;
+    }
+    copy() {
+        return new ReferenceNode(this.citationID, this.authors, this.year, this.title, this.source, this.url, this.summary, this.short);
+    }
+    withChildReplaced() { return undefined; }
+    withContentInRange() { return this.copy(); }
+    withCitationID(id) { return new ReferenceNode(id, this.authors, this.year, this.title, this.source, this.url, this.summary, this.short); }
+    withAuthors(authors) { return new ReferenceNode(this.citationID, authors, this.year, this.title, this.source, this.url, this.summary, this.short); }
+    withYear(year) { return new ReferenceNode(this.citationID, this.authors, year, this.title, this.source, this.url, this.summary, this.short); }
+    withTitle(title) { return new ReferenceNode(this.citationID, this.authors, this.year, title, this.source, this.url, this.summary, this.short); }
+    withSource(source) { return new ReferenceNode(this.citationID, this.authors, this.year, this.title, source, this.url, this.summary, this.short); }
+    withURL(url) { return new ReferenceNode(this.citationID, this.authors, this.year, this.title, this.source, url, this.summary, this.short); }
+    withSummary(summary) { return new ReferenceNode(this.citationID, this.authors, this.year, this.title, this.source, this.url, summary, this.short); }
+}

package/models/chapter/RootNode.d.ts

@@ -0,0 +1,5 @@
+import type ChapterNode from "./ChapterNode";
+import type EmbedNode from "./EmbedNode";
+import type FormatNode from "./FormatNode";
+declare type RootNode = ChapterNode | FormatNode | EmbedNode;
+export default RootNode;

package/models/chapter/RootNode.js

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

package/models/chapter/RuleNode.d.ts

@@ -0,0 +1,15 @@
+import type Node from "./Node";
+import BlockNode from "./BlockNode";
+export default class RuleNode extends BlockNode {
+    constructor();
+    getType(): string;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getParentOf(): Node | undefined;
+    getFormats(): never[];
+    getChildren(): Node[];
+    copy(): this;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+}

package/models/chapter/RuleNode.js

@@ -0,0 +1,16 @@
+import BlockNode from "./BlockNode";
+export default class RuleNode extends BlockNode {
+    constructor() {
+        super();
+    }
+    getType() { return "rule"; }
+    toText() { return ""; }
+    toBookdown() { return "-"; }
+    toHTML() { return `<hr/>`; }
+    getParentOf() { return undefined; }
+    getFormats() { return []; }
+    getChildren() { return []; }
+    copy() { return new RuleNode(); }
+    withChildReplaced() { return undefined; }
+    withContentInRange() { return this.copy(); }
+}

package/models/chapter/TableNode.d.ts

@@ -0,0 +1,35 @@
+import type Node from "./Node";
+import type Position from "./Position";
+import FormatNode from "./FormatNode";
+import BlockNode from "./BlockNode";
+import type { CaretRange } from "./Caret";
+declare type Location = {
+    row: number;
+    column: number;
+};
+export default class TableNode extends BlockNode {
+    #private;
+    constructor(rows: FormatNode[][], position?: Position, caption?: FormatNode);
+    getType(): string;
+    getRows(): FormatNode[][];
+    getRowCount(): number;
+    getColumnCount(): number;
+    getPosition(): Position;
+    getCaption(): FormatNode;
+    getFormats(): FormatNode[];
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getChildren(): FormatNode[];
+    locate(format: FormatNode): Location | undefined;
+    getCell(row: number, col: number): FormatNode | undefined;
+    getParentOf(node: Node): Node | undefined;
+    copy(): this;
+    withChildReplaced(node: FormatNode, replacement: FormatNode | undefined): this | undefined;
+    withNewRow(index: number): TableNode | undefined;
+    withoutRow(index: number): TableNode | undefined;
+    withoutColumn(index: number): TableNode | undefined;
+    withNewColumn(index: number): TableNode | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+}
+export {};

package/models/chapter/TableNode.js

@@ -0,0 +1,176 @@
+import FormatNode from "./FormatNode";
+import TextNode from "./TextNode";
+import BlockNode from "./BlockNode";
+export default class TableNode extends BlockNode {
+    #rows;
+    #caption;
+    #position;
+    constructor(rows, position, caption) {
+        super();
+        this.#rows = rows.map(r => r.map(c => c.withTextIfEmpty()));
+        this.#position = position ? position : "|";
+        this.#caption = caption === undefined ? new FormatNode("", [new TextNode()]) : caption.withTextIfEmpty();
+    }
+    getType() { return "table"; }
+    getRows() { return this.#rows; }
+    getRowCount() { return this.#rows.length; }
+    getColumnCount() { return this.#rows.length === 0 ? 0 : this.#rows[0].length; }
+    getPosition() { return this.#position; }
+    getCaption() { return this.#caption; }
+    getFormats() {
+        const formats = [];
+        this.#rows.forEach(row => row.forEach(cell => { formats.push(cell); }));
+        return [...formats, this.#caption];
+    }
+    toText() {
+        return this.#rows.map(row => row.map(cell => cell.toText()).join(", ")).join(", ");
+    }
+    toBookdown() {
+        return this.#rows.map(row => `,${row.map(cell => cell.toBookdown()).join("|")}`).join("\n") +
+            `\n${this.#position === "|" ? "" : this.#position}${this.#caption ? "" + this.#caption.toBookdown() : ""}`;
+    }
+    toHTML() {
+        return `<table><tbody>${this.#rows.map(row => `<tr>${row.map(cell => `<td>${cell.toHTML()}</td>`).join("")}`).join("")}</tbody></table><center>${this.#caption.toHTML()}</center>`;
+    }
+    getChildren() {
+        const children = [];
+        this.#rows.forEach(row => row.forEach(cell => children.push(cell)));
+        children.push(this.#caption);
+        return children;
+    }
+    locate(format) {
+        for (let r = 0; r < this.#rows.length; r++) {
+            const row = this.#rows[r];
+            for (let c = 0; c < row.length; c++) {
+                if (row[c] === format)
+                    return { row: r, column: c };
+            }
+        }
+    }
+    getCell(row, col) {
+        return row >= 0 && row < this.#rows.length && this.#rows.length > 0 && col >= 0 && col < this.#rows[0].length ?
+            this.#rows[row][col] :
+            undefined;
+    }
+    getParentOf(node) {
+        for (let r = 0; r < this.#rows.length; r++) {
+            const row = this.#rows[r];
+            for (let c = 0; c < row.length; c++) {
+                if (row[c] === node)
+                    return this;
+                const parent = row[c].getParentOf(node);
+                if (parent !== undefined)
+                    return parent;
+            }
+        }
+        return node === this.#caption ? this : this.#caption.getParentOf(node);
+    }
+    copy() {
+        const rows = [];
+        this.#rows.forEach(row => {
+            const cells = [];
+            row.forEach(cell => cells.push(cell.copy()));
+            rows.push(cells);
+        });
+        return new TableNode(rows, this.#position, this.#caption ? this.#caption.copy() : undefined);
+    }
+    withChildReplaced(node, replacement) {
+        // If it's just the caption, make a new node with the new credit.
+        if (node === this.#caption && (replacement instanceof FormatNode || replacement === undefined))
+            return new TableNode(this.#rows, this.#position, replacement);
+        // If it's a cell, update the cell.
+        if (node instanceof FormatNode && replacement instanceof FormatNode) {
+            // Does this table contain node we're replacing?
+            let updateRow = 0;
+            let updateColumn = -1;
+            for (; updateRow < this.#rows.length; updateRow++) {
+                updateColumn = this.#rows[updateRow].indexOf(node);
+                if (updateColumn >= 0)
+                    break;
+            }
+            // Make new rows with the updated cell.
+            if (updateRow < this.#rows.length && updateColumn >= 0) {
+                const newRows = this.#rows.map(row => [...row]);
+                newRows[updateRow][updateColumn] = replacement;
+                return new TableNode(newRows, this.#position, this.#caption);
+            }
+        }
+    }
+    withNewRow(index) {
+        if (index < 0 || index > this.#rows.length)
+            return;
+        // Figure out how many columns the first row has, then create a row with that many columns
+        // and an empty FormatNode.
+        const columnCount = this.#rows.length === 0 ? 0 : this.#rows[0].length;
+        const column = [];
+        for (let c = 0; c < columnCount; c++)
+            column.push(new FormatNode("", [new TextNode()]));
+        const newRows = this.#rows.slice();
+        newRows.splice(index, 0, column);
+        return new TableNode(newRows, this.#position, this.#caption);
+    }
+    withoutRow(index) {
+        if (index < 0 || index >= this.#rows.length)
+            return;
+        const newRows = this.#rows.slice();
+        newRows.splice(index, 1);
+        return new TableNode(newRows, this.#position, this.#caption);
+    }
+    withoutColumn(index) {
+        if (index < 0 || index >= this.getColumnCount())
+            return;
+        const newRows = this.#rows.slice();
+        for (let r = 0; r < this.#rows.length; r++)
+            newRows[r].splice(index, 1);
+        return new TableNode(newRows, this.#position, this.#caption);
+    }
+    withNewColumn(index) {
+        if (this.#rows.length > 0 && (index < 0 || index > this.#rows[0].length))
+            return;
+        // Figure out how many rows the table has and add a column 
+        const newRows = this.#rows.slice();
+        for (let r = 0; r < this.#rows.length; r++) {
+            newRows[r] = newRows[r].slice();
+            newRows[r].splice(index, 0, new FormatNode("", [new TextNode()]));
+        }
+        return new TableNode(newRows, this.#position, this.#caption);
+    }
+    withContentInRange(range) {
+        const containsStart = this.contains(range.start.node);
+        const containsEnd = this.contains(range.end.node);
+        if (!containsStart && !containsEnd)
+            return this.copy();
+        // If it contains the start, skip rows until we find the cell with the start node.
+        // If it contains the end, skip rows after we find the cell with the end node.
+        let r = 0, c = 0;
+        let foundStart = false;
+        let foundEnd = false;
+        let newRows = [];
+        for (; r < this.#rows.length; r++, c = 0) {
+            const row = this.#rows[r];
+            // Skip this row if this table contains the start node and we haven't found it and the row doesn't contain it
+            if (containsStart && !foundStart && row.find(r => r.contains(range.start.node)) === undefined)
+                continue;
+            // Stop if we found the end row.
+            if (containsEnd && foundEnd)
+                break;
+            newRows.push([]);
+            for (; c < row.length; c++) {
+                if (!foundStart && row[c].contains(range.start.node))
+                    foundStart = true;
+                const newCell = row[c].withContentInRange(range);
+                if (newCell === undefined)
+                    return;
+                newRows[newRows.length - 1].push((((containsStart && foundStart) || !containsStart) && ((containsEnd && !foundEnd) || !containsEnd)) ?
+                    newCell :
+                    new FormatNode("", [new TextNode()]));
+                if (row[c].contains(range.end.node))
+                    foundEnd = true;
+            }
+        }
+        const newCaption = this.#caption.withContentInRange(range);
+        if (newCaption === undefined)
+            return;
+        return new TableNode(newRows, this.#position, newCaption);
+    }
+}

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

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

package/models/chapter/TableNode.test.js

@@ -0,0 +1,31 @@
+import { test, expect } from 'vitest';
+import FormatNode from "./FormatNode";
+import TextNode from "./TextNode";
+import TableNode from "./TableNode";
+const tl = new FormatNode("", [new TextNode("tl")]);
+const tr = new FormatNode("", [new TextNode("tr")]);
+const bl = new FormatNode("", [new TextNode("bl")]);
+const br = new FormatNode("", [new TextNode("br")]);
+const caption = new FormatNode("", [new TextNode("hi")]);
+const table = new TableNode([
+    [tl, tr],
+    [bl, br],
+], "|", caption);
+test("Replace", () => {
+    expect(table.withChildReplaced(tl, new FormatNode("", [new TextNode("new")]))?.toBookdown())
+        .toBe(",new|tr\n,bl|br\nhi");
+    expect(table.withChildReplaced(caption, new FormatNode("", [new TextNode("bye")]))?.toBookdown())
+        .toBe(",tl|tr\n,bl|br\nbye");
+});
+test("Insert", () => {
+    expect(table.withNewRow(0)?.toBookdown())
+        .toBe(",|\n,tl|tr\n,bl|br\nhi");
+    expect(table.withNewColumn(0)?.toBookdown())
+        .toBe(",|tl|tr\n,|bl|br\nhi");
+});
+test("Delete", () => {
+    expect(table.withoutRow(0)?.toBookdown())
+        .toBe(",bl|br\nhi");
+    expect(table.withoutColumn(0)?.toBookdown())
+        .toBe(",tr\n,br\nhi");
+});

package/models/chapter/TextNode.d.ts

@@ -0,0 +1,36 @@
+import type Caret from "./Caret";
+import type { CaretRange } from "./Caret";
+import FormatNode from "./FormatNode";
+import Node from "./Node";
+import BlocksNode from "./BlocksNode";
+import type RootNode from "./RootNode";
+export default class TextNode extends Node {
+    #private;
+    constructor(text?: string);
+    getType(): string;
+    getText(): string;
+    getLength(): number;
+    getCaretPositionCount(): number;
+    getParentOf(): Node | undefined;
+    getFirstCaret(): Caret;
+    getLastCaret(): Caret;
+    toText(): string;
+    toBookdown(): string;
+    toHTML(): string;
+    getChildren(): never[];
+    copy(): this;
+    isItalic(root: Node): boolean;
+    isBold(root: Node): boolean;
+    isEmpty(): boolean;
+    getFormat(root: Node): FormatNode | undefined;
+    getFormatRoot(root: Node): FormatNode | undefined;
+    getBlocks(root: Node): BlocksNode | undefined;
+    getNextCaret(index: number): Caret | undefined;
+    getPreviousCaret(index: number): Caret | undefined;
+    nextWord(root: RootNode, index?: number): Caret;
+    previousWord(root: RootNode, index?: number): Caret;
+    withChildReplaced(): undefined;
+    withCharacterAt(char: string, index: number): TextNode | undefined;
+    withoutRange(range: CaretRange): TextNode | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+}

package/models/chapter/TextNode.js

@@ -0,0 +1,136 @@
+import FormatNode from "./FormatNode";
+import Node from "./Node";
+import AtomNode from "./AtomNode";
+import BlocksNode from "./BlocksNode";
+export default class TextNode extends Node {
+    #text;
+    constructor(text = "") {
+        super();
+        this.#text = text;
+    }
+    getType() { return "text"; }
+    getText() { return this.#text; }
+    getLength() { return this.#text.length; }
+    getCaretPositionCount() { return this.#text.length; }
+    getParentOf() { return undefined; }
+    getFirstCaret() { return { node: this, index: 0 }; }
+    getLastCaret() { return { node: this, index: this.#text.length }; }
+    toText() { return this.#text; }
+    toBookdown() {
+        // Escape all characters with special meaning inside content nodes: _*`<^{~\[@% and :'s with no space after
+        return this.#text
+            .replace(/\\/g, '\\\\') // This has to go first! Otherwise it breaks all of the others below.
+            .replace(/_/g, '\\_')
+            .replace(/\*/g, '\\*')
+            .replace(/`/g, '\\`')
+            .replace(/</g, '\\<')
+            .replace(/\^/g, '\\^')
+            .replace(/{/g, '\\{')
+            .replace(/~/g, '\\~')
+            .replace(/ %/g, ' \\%')
+            .replace(/\[/g, '\\[')
+            .replace(/@/g, '\\@')
+            .replace(/(:)([a-z])/g, '\\:$2');
+    }
+    toHTML() {
+        return this.#text
+            .replace("<", "&lt;")
+            .replace(">", "&gt;")
+            .replace("&", "&amp;")
+            .replace('"', "&quot;")
+            .replace("'", "&#39;");
+    }
+    getChildren() { return []; }
+    copy() { return new TextNode(this.#text); }
+    isItalic(root) { return this.getAncestors(root).filter(p => p instanceof FormatNode && p.getFormat() === "_").length > 0; }
+    isBold(root) { return this.getAncestors(root).filter(p => p instanceof FormatNode && p.getFormat() === "*").length > 0; }
+    isEmpty() { return this.getLength() === 0; }
+    getFormat(root) {
+        return this.getClosestParentOfType(root, FormatNode);
+    }
+    getFormatRoot(root) {
+        // The format root is the highest format in the tree that contains this text.
+        // There is one exception to this, however: formats inside atom nodes shouldn't traverse
+        // past the atom node, since should be isolated from edits outside the atom.
+        const atom = this.getClosestParentMatching(root, p => p instanceof AtomNode);
+        if (atom && atom.getMeta() instanceof FormatNode)
+            return atom.getMeta();
+        // If this isn't in an atom, just return the highest format this is in.
+        return this.getFarthestParentMatching(root, p => p instanceof FormatNode);
+    }
+    getBlocks(root) {
+        return this.getClosestParentOfType(root, BlocksNode);
+    }
+    getNextCaret(index) {
+        return index < this.#text.length ? { node: this, index: index + 1 } : undefined;
+    }
+    getPreviousCaret(index) {
+        return index > 0 ? { node: this, index: index - 1 } : undefined;
+    }
+    nextWord(root, index) {
+        if (index === undefined)
+            index = 0;
+        // Search for the space after the given index.
+        let i = index + 1;
+        while (i < this.getLength() && this.#text.charAt(i).match(/\W/))
+            i++;
+        while (i < this.getLength() && this.#text.charAt(i).match(/\w/))
+            i++;
+        // If we found one in this node, return it.
+        if (i < this.getLength() || (i === this.getLength() && this.#text.charAt(i - 1).match(/\w/)))
+            return { node: this, index: i };
+        // Otherwise, find the next text node's next word boundary.
+        const format = this.getFormatRoot(root);
+        const formatTextNodes = format ? format.getTextNodes() : undefined;
+        const nextNode = root.getNextTextOrAtom(this);
+        const nextWord = nextNode?.nextWord(root);
+        // If there isn't one, just go to the end of this.
+        if (formatTextNodes && nextNode && this === formatTextNodes[formatTextNodes.length - 1])
+            return { node: nextNode, index: 0 };
+        else if (nextWord === undefined)
+            return { node: this, index: this.#text.length };
+        else
+            return nextWord;
+    }
+    previousWord(root, index) {
+        if (index === undefined)
+            index = this.#text.length;
+        // Scan left until we find a word character, then keep scanning until we reach a non-word character.
+        let i = index - 1;
+        while (i > 0 && this.#text.charAt(i - 1).match(/\W/))
+            i--;
+        while (i > 0 && this.#text.charAt(i - 1).match(/\w/))
+            i--;
+        // If we found one in this node, return it.
+        if (i > 0 || (i === 0 && this.#text.charAt(0).match(/\w/)))
+            return { node: this, index: i };
+        // Otherwise, find the next text node's next word boundary.
+        const format = this.getFormatRoot(root);
+        const formatTextNodes = format ? format.getTextNodes() : undefined;
+        const previousNode = root.getPreviousTextOrAtom(this);
+        const previousWord = previousNode?.previousWord(root);
+        // If there isn't one, just go to the end of this.
+        if (formatTextNodes && previousNode && this === formatTextNodes[0])
+            return { node: previousNode, index: previousNode instanceof TextNode ? previousNode.getLength() : 0 };
+        else if (previousWord === undefined)
+            return { node: this, index: 0 };
+        else
+            return previousWord;
+    }
+    withChildReplaced() { return undefined; }
+    withCharacterAt(char, index) {
+        if (index < 0 || index > this.#text.length)
+            return undefined;
+        return new TextNode(this.#text.slice(0, index) + char + this.#text.slice(index));
+    }
+    withoutRange(range) {
+        if (range.start.node !== this && range.end.node !== this)
+            return;
+        return new TextNode(this.#text.substring(0, range.start.index) + this.#text.substring(range.end.index));
+    }
+    withContentInRange(range) {
+        const includesStart = range.start.node === this;
+        const includesEnd = range.end.node === this;
+        return new TextNode(this.#text.substring(includesStart ? range.start.index : 0, includesEnd ? range.end.index : this.#text.length));
+    }
+}