bookish-press 0.4.47 → 0.4.49

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

@@ -1,48 +1,24 @@
 import Node from './Node';
-import type ErrorNode from './ErrorNode';
 import TextNode from './TextNode';
-import type Caret from './Caret';
-import {
-    caretRangeToIndexRange,
-    caretToIndex,
-    indexToCaret,
-    type CaretRange,
-} from './Caret';
+import { caretRangeToIndexRange, caretToIndex, indexToCaret, } from './Caret';
 import MetadataNode from './MetadataNode';
 import AtomNode from './AtomNode';
-import type Edit from './Edit';
-
-export type Format = '' | '*' | '_' | '^' | 'v';
-export type FormatNodeSegmentType =
-    | FormatNode
-    | TextNode
-    | ErrorNode
-    | MetadataNode<any>
-    | AtomNode<any>;
-
 export default class FormatNode extends Node {
-    readonly #format: Format;
-    readonly #segments: FormatNodeSegmentType[];
-
-    constructor(format: Format, segments: FormatNodeSegmentType[]) {
+    #format;
+    #segments;
+    constructor(format, segments) {
         super();
-
         this.#format = format;
         // Remove consecutive empty text nodes.
         this.#segments = segments.filter((item, position, list) => {
-            if (
-                position === 0 ||
+            if (position === 0 ||
                 !(item instanceof TextNode) ||
-                item.getLength() > 0
-            )
+                item.getLength() > 0)
                 return true;
             const previous = list[position - 1];
-            return !(
-                previous instanceof TextNode && previous.getLength() === 0
-            );
+            return !(previous instanceof TextNode && previous.getLength() === 0);
         });
     }
-
     getType() {
         return 'formatted';
     }
@@ -56,130 +32,100 @@ export default class FormatNode extends Node {
         return this.#segments.length === 0;
     }
     isEmptyText() {
-        return (
-            this.#segments.length === 1 &&
+        return (this.#segments.length === 1 &&
             this.#segments[0] instanceof TextNode &&
-            this.#segments[0].getText() === ''
-        );
+            this.#segments[0].getText() === '');
     }
     getLength() {
         return this.#segments.length;
     }
-    getParentOf(node: Node): Node | undefined {
+    getParentOf(node) {
         return this.#segments
             .map((b) => (b === node ? this : b.getParentOf(node)))
             .find((b) => b !== undefined);
     }
-
-    toText(): string {
+    toText() {
         return this.#segments.map((segment) => segment.toText()).join(' ');
     }
-    toHTML(): string {
+    toHTML() {
         const format = this.#format;
         const segments = this.#segments.map((s) => s.toHTML()).join('');
-        if (format === '*') return `<strong>${segments}</strong>`;
-        else if (format === '_') return `<em>${segments}</em>`;
-        else if (format === '^') return `<sup>${segments}</sup>`;
-        else if (format === 'v') return `<sub>${segments}</sub>`;
-        else return segments;
-    }
-
-    toBookdown(): string {
-        return (
-            (this.#format === 'v' ? '^v' : this.#format) +
+        if (format === '*')
+            return `<strong>${segments}</strong>`;
+        else if (format === '_')
+            return `<em>${segments}</em>`;
+        else if (format === '^')
+            return `<sup>${segments}</sup>`;
+        else if (format === 'v')
+            return `<sub>${segments}</sub>`;
+        else
+            return segments;
+    }
+    toBookdown() {
+        return ((this.#format === 'v' ? '^v' : this.#format) +
             this.#segments
-                .map((s) =>
-                    s instanceof AtomNode ? s.toBookdown(this) : s.toBookdown()
-                )
+                .map((s) => s instanceof AtomNode ? s.toBookdown(this) : s.toBookdown())
                 .join('') +
-            (this.#format === 'v' ? '^' : this.#format)
-        );
+            (this.#format === 'v' ? '^' : this.#format));
     }
-
     getChildren() {
         return this.#segments;
     }
-
-    getFirstTextNode(): TextNode {
+    getFirstTextNode() {
         const text = this.getTextNodes();
         return text[0];
     }
-
-    getLastTextNode(): TextNode {
+    getLastTextNode() {
         const text = this.getTextNodes();
         return text[text.length - 1];
     }
-
-    copy(): this {
-        return new FormatNode(
-            this.#format,
-            this.#segments.map((s) => s.copy())
-        ) as this;
+    copy() {
+        return new FormatNode(this.#format, this.#segments.map((s) => s.copy()));
     }
-
-    getTextNodes(): TextNode[] {
-        return this.getNodes().filter(
-            (n) => n instanceof TextNode
-        ) as TextNode[];
+    getTextNodes() {
+        return this.getNodes().filter((n) => n instanceof TextNode);
     }
-
     // Get all text or atom nodes in this format, except for any inside an atom node,
     // as this is used for navigation and editing, and they should be isolated from that.
-    getTextAndAtomNodes(): (TextNode | AtomNode<any>)[] {
-        return this.getNodes().filter(
-            (n) => n instanceof TextNode || n instanceof AtomNode
-        ) as (TextNode | AtomNode<any>)[];
-    }
-
-    getAdjacentTextOrAtom(
-        node: TextNode | AtomNode<any>,
-        next: boolean
-    ): TextNode | AtomNode<any> | undefined {
+    getTextAndAtomNodes() {
+        return this.getNodes().filter((n) => n instanceof TextNode || n instanceof AtomNode);
+    }
+    getAdjacentTextOrAtom(node, next) {
         // Find all of the text and atom nodes not in atom nodes in this node.
         const text = this.getTextAndAtomNodes().filter((n) => {
             const atomAncestor = n.getClosestParentOfType(this, AtomNode);
-            return (
-                atomAncestor === undefined ||
+            return (atomAncestor === undefined ||
                 (atomAncestor instanceof AtomNode &&
-                    atomAncestor.getMeta() === this)
-            );
+                    atomAncestor.getMeta() === this));
         });
         const index = text.indexOf(node);
         return index === undefined
             ? undefined
             : next
-            ? index >= 0 && index < text.length - 1
-                ? text[index + 1]
-                : undefined
-            : index > 0 && index <= text.length
-            ? text[index - 1]
-            : undefined;
-    }
-
-    getNextTextOrAtom(
-        node: TextNode | AtomNode<any>
-    ): TextNode | AtomNode<any> | undefined {
+                ? index >= 0 && index < text.length - 1
+                    ? text[index + 1]
+                    : undefined
+                : index > 0 && index <= text.length
+                    ? text[index - 1]
+                    : undefined;
+    }
+    getNextTextOrAtom(node) {
         return this.getAdjacentTextOrAtom(node, true);
     }
-
-    getPreviousTextOrAtom(
-        node: TextNode | AtomNode<any>
-    ): TextNode | AtomNode<any> | undefined {
+    getPreviousTextOrAtom(node) {
         return this.getAdjacentTextOrAtom(node, false);
     }
-
-    getAdjacentCaret(caret: Caret, next: boolean): Caret | undefined {
-        if (
-            !(caret.node instanceof TextNode) &&
-            !(caret.node instanceof AtomNode)
-        )
+    getAdjacentCaret(caret, next) {
+        if (!(caret.node instanceof TextNode) &&
+            !(caret.node instanceof AtomNode))
             return;
         // Is there an adjascent caret in the current text node? If so, return it.
         if (caret.node instanceof TextNode) {
             const adjacentText = next
                 ? caret.node.getNextCaret(caret.index)
                 : caret.node.getPreviousCaret(caret.index);
-            if (adjacentText !== undefined) return adjacentText;
+            if (adjacentText !== undefined)
+                return adjacentText;
         }
         // If there's not, is there an adjacent caret in the sequence of text and atom nodes?
         const adjacentNode = this.getAdjacentTextOrAtom(caret.node, next);
@@ -195,30 +141,29 @@ export default class FormatNode extends Node {
                             : 1
                         : 0
                     : adjacentNode instanceof TextNode
-                    ? adjacentNode.isEmpty()
-                        ? 0
-                        : adjacentNode.getLength() - 1
-                    : 0,
+                        ? adjacentNode.isEmpty()
+                            ? 0
+                            : adjacentNode.getLength() - 1
+                        : 0,
             };
         }
         // Otherwise, there is no adjascent caret.
         return undefined;
     }
-
-    getFirstCaret(): Caret | undefined {
+    getFirstCaret() {
         const text = this.getTextNodes();
-        if (text.length === 0) return undefined;
+        if (text.length === 0)
+            return undefined;
         return { node: this.getTextNodes()[0], index: 0 };
     }
-
-    getLastCaret(): Caret | undefined {
+    getLastCaret() {
         const text = this.getTextNodes();
-        if (text.length === 0) return undefined;
+        if (text.length === 0)
+            return undefined;
         const last = text[text.length - 1];
         return { node: last, index: last.getLength() };
     }
-
-    getSelection(): CaretRange {
+    getSelection() {
         const first = this.getFirstTextNode();
         const last = this.getLastTextNode();
         return {
@@ -226,159 +171,117 @@ export default class FormatNode extends Node {
             end: { node: last, index: last.getLength() },
         };
     }
-
-    getIndexOfTextNode(node: TextNode): number | undefined {
+    getIndexOfTextNode(node) {
         const text = this.getTextNodes();
         return text.indexOf(node);
     }
-
-    getSelectedText(range: CaretRange): string | undefined {
-        if (
-            !(range.start.node instanceof TextNode) ||
-            !(range.end.node instanceof TextNode)
-        )
+    getSelectedText(range) {
+        if (!(range.start.node instanceof TextNode) ||
+            !(range.end.node instanceof TextNode))
             return undefined;
-
         const start = this.getIndexOfTextNode(range.start.node);
         const end = this.getIndexOfTextNode(range.end.node);
-
-        if (start === undefined || end === undefined) return undefined;
-
+        if (start === undefined || end === undefined)
+            return undefined;
         return this.getTextNodes()
             .map((current, index) => {
-                return current === range.start.node
-                    ? current === range.end.node
-                        ? current
-                              .getText()
-                              .substring(range.start.index, range.end.index)
-                        : current.getText().substring(range.start.index)
-                    : index > start && index < end
+            return current === range.start.node
+                ? current === range.end.node
+                    ? current
+                        .getText()
+                        .substring(range.start.index, range.end.index)
+                    : current.getText().substring(range.start.index)
+                : index > start && index < end
                     ? current.getText()
                     : current === range.end.node
-                    ? current.getText().substring(0, range.end.index)
-                    : '';
-            })
+                        ? current.getText().substring(0, range.end.index)
+                        : '';
+        })
             .join('');
     }
-
     withTextIfEmpty() {
         return this.isEmpty() ? this.withSegmentAppended(new TextNode()) : this;
     }
-
-    withSegmentPrepended(segment: FormatNodeSegmentType): FormatNode {
+    withSegmentPrepended(segment) {
         return new FormatNode(this.#format, [segment, ...this.#segments]);
     }
-
-    withSegmentAppended(segment: FormatNodeSegmentType): FormatNode {
+    withSegmentAppended(segment) {
         return new FormatNode(this.#format, [...this.#segments, segment]);
     }
-
-    withSegmentReplaced(
-        segment: FormatNodeSegmentType,
-        replacement: FormatNodeSegmentType
-    ): this | undefined {
+    withSegmentReplaced(segment, replacement) {
         const index = this.#segments.indexOf(segment);
-        if (index < 0) return undefined;
-
+        if (index < 0)
+            return undefined;
         const segments = this.#segments.slice();
         segments[index] = replacement;
-
-        return new FormatNode(this.#format, segments) as this;
+        return new FormatNode(this.#format, segments);
     }
-
-    withoutSegment(segment: FormatNodeSegmentType): this | undefined {
+    withoutSegment(segment) {
         const index = this.#segments.indexOf(segment);
-        if (index < 0) return undefined;
+        if (index < 0)
+            return undefined;
         const newSegments = this.#segments.slice();
         newSegments.splice(index, 1);
-        return new FormatNode(this.#format, newSegments) as this;
+        return new FormatNode(this.#format, newSegments);
     }
-
-    withChildReplaced(
-        node: FormatNodeSegmentType,
-        replacement: FormatNodeSegmentType | undefined
-    ) {
+    withChildReplaced(node, replacement) {
         return replacement === undefined
-            ? (this.withoutSegment(node) as this)
-            : (this.withSegmentReplaced(node, replacement) as this);
+            ? this.withoutSegment(node)
+            : this.withSegmentReplaced(node, replacement);
     }
-
     // Creates two formatted nodes that split this node at the given caret location.
-    split(caret: Caret): [FormatNode, FormatNode] | undefined {
+    split(caret) {
         // We can only copy if
         // ... this has a parent.
         // ... the given caret is in this formatted node.
         // ... the caret is on a text node.
         if (!(caret.node instanceof TextNode) || !this.contains(caret.node))
             return undefined;
-
         const firstCaret = this.getFirstCaret();
         const lastCaret = this.getLastCaret();
         if (firstCaret === undefined || lastCaret === undefined)
             return undefined;
-
         // Delete everything after in the first, everything before in the second.
         const first = this.withoutRange({ start: caret, end: lastCaret });
         const second = this.withoutRange({ start: firstCaret, end: caret });
-
-        if (first !== undefined && second !== undefined) return [first, second];
+        if (first !== undefined && second !== undefined)
+            return [first, second];
     }
-
-    withoutRange(range: CaretRange): FormatNode | undefined {
+    withoutRange(range) {
         return this.withFormat(range, undefined);
     }
-
     // This function takes the given range, and if it's within the bounds of this FormatNode,
     // produces a new FormatNode that either formats the given range with the given format or deletes the range if the format is undefined.
     // It's approach is to scan through every text, meta, and atom node build a new format based on the requested format.
-    withFormat(
-        range: CaretRange,
-        format: Format | undefined
-    ): FormatNode | undefined {
+    withFormat(range, format) {
         // This only transforms ranges that start and end with text/atom nodes in this format node.
-        if (
-            !(
-                range.start.node instanceof TextNode ||
-                range.start.node instanceof AtomNode
-            ) ||
-            !(
-                range.end.node instanceof TextNode ||
-                range.end.node instanceof AtomNode
-            ) ||
-            !(this.contains(range.start.node) && this.contains(range.end.node))
-        )
+        if (!(range.start.node instanceof TextNode ||
+            range.start.node instanceof AtomNode) ||
+            !(range.end.node instanceof TextNode ||
+                range.end.node instanceof AtomNode) ||
+            !(this.contains(range.start.node) && this.contains(range.end.node)))
             return;
-
         const sortedRange = this.sortRange(range);
-
         // Remember the text positions so we can return a new range in the new tree.
         const selectionStartIndex = caretToIndex(this, sortedRange.start);
         const selectionEndIndex = caretToIndex(this, sortedRange.end);
-
-        if (
-            selectionStartIndex === undefined ||
-            selectionEndIndex === undefined
-        )
+        if (selectionStartIndex === undefined ||
+            selectionEndIndex === undefined)
             return;
-
         // Remember if the selection is zero width.
         let zeroWidthSelection = selectionStartIndex === selectionEndIndex;
-
         // Find all of the content in the node, except for format nodes and decendants of atom nodes that have format nodes,
         // to construct a new format tree with the old content.
-        const everythingButFormats = this.getNodes().filter(
-            (n) => !(n instanceof FormatNode)
-        );
-
+        const everythingButFormats = this.getNodes().filter((n) => !(n instanceof FormatNode));
         // Check if all of the selected content has the requested format so we can toggle it if so.
         let checkIndex = 0; // This tracks the current location in our scan.
         let editingEmptyNode = false; // This remembers the special case of the caret being inside an empty text node.
         let alreadyApplied = false; // We assume it's not applied until proven otherwise.
         let nodeCount = 0;
         let nodesWithFormat = 0;
-
         // It's already applied if we're deleting (in which case this doesn't apply).
-        if (format === undefined) alreadyApplied = true;
+        if (format === undefined)
+            alreadyApplied = true;
         // Otherwise, formatting is already applied if all of the non-format nodes already have this format.
         // We need to know this so we can toggle the format off.
         else {
@@ -391,10 +294,8 @@ export default class FormatNode extends Node {
                     }
                     // If this node is empty but contains a zero-width selection, remember it, since this is the only node for which formats are relevant.
                     else if (node.getText().length === 0) {
-                        if (
-                            checkIndex === selectionStartIndex &&
-                            zeroWidthSelection
-                        ) {
+                        if (checkIndex === selectionStartIndex &&
+                            zeroWidthSelection) {
                             editingEmptyNode = true;
                             alreadyApplied = parent
                                 .getFormats(this)
@@ -407,46 +308,41 @@ export default class FormatNode extends Node {
                         const parentIsFormatted = parent
                             .getFormats(this)
                             .includes(format);
-                        const selectionContainsNode =
-                            (selectionStartIndex > checkIndex &&
-                                selectionStartIndex <
-                                    checkIndex +
-                                        node.getCaretPositionCount() -
-                                        1) ||
+                        const selectionContainsNode = (selectionStartIndex > checkIndex &&
+                            selectionStartIndex <
+                                checkIndex +
+                                    node.getCaretPositionCount() -
+                                    1) ||
                             (selectionEndIndex > checkIndex &&
                                 selectionEndIndex <
                                     checkIndex +
                                         node.getCaretPositionCount() -
                                         1);
-                        const nodeContainsSelection =
-                            selectionStartIndex >= checkIndex &&
+                        const nodeContainsSelection = selectionStartIndex >= checkIndex &&
                             selectionEndIndex <=
                                 checkIndex + node.getCaretPositionCount();
                         checkIndex += node.getCaretPositionCount();
                         if (nodeContainsSelection || selectionContainsNode) {
                             nodeCount++;
-                            if (parentIsFormatted) nodesWithFormat++;
+                            if (parentIsFormatted)
+                                nodesWithFormat++;
                         }
                     }
                 }
                 // Treat all non-text as containing the requested format.
-                else return true;
+                else
+                    return true;
             });
             if (nodeCount > 0 && nodesWithFormat === nodeCount)
                 alreadyApplied = true;
         }
-
         // Reformat everything. The strategy is to step through each character, atom node, and metadata node in this format node
         // and create a new series of formats that preserve existing formatting while applying new formatting to the selection.
-        let newFormats: {
-            format: Format;
-            segments: FormatNodeSegmentType[];
-        }[] = [{ format: '', segments: [] }]; // A stack of formats we're constructing.
+        let newFormats = [{ format: '', segments: [] }]; // A stack of formats we're constructing.
         let textIndex = 0;
         let currentText = ''; // The current text we've accumulated, inserted before each format change and at the end.
         let formattingEmptyNode = false;
         let emptyNode = undefined;
-
         function saveText() {
             // If there's some text, update the current format with the current text, then reset it.
             if (currentText.length > 0) {
@@ -454,60 +350,45 @@ export default class FormatNode extends Node {
                 currentText = '';
             }
         }
-
         function inRange() {
-            return (
-                selectionStartIndex !== undefined &&
+            return (selectionStartIndex !== undefined &&
                 selectionEndIndex !== undefined &&
                 textIndex >= selectionStartIndex &&
-                textIndex < selectionEndIndex
-            );
+                textIndex < selectionEndIndex);
         }
-
         function getFormats() {
             // We don't include non-formatted text in the list of formats applied.
             return newFormats.map((f) => f.format).filter((f) => f !== '');
         }
-
         function finishFormat() {
             const formatSpec = newFormats[0];
             newFormats.shift();
             // Keep the new format clean by only adding the format node if it's not empty, or if it's a zero width selection.
-            if (
-                formatSpec.segments.length > 0 ||
-                (zeroWidthSelection && textIndex === selectionStartIndex)
-            )
-                newFormats[0].segments.push(
-                    new FormatNode(formatSpec.format, formatSpec.segments)
-                );
+            if (formatSpec.segments.length > 0 ||
+                (zeroWidthSelection && textIndex === selectionStartIndex))
+                newFormats[0].segments.push(new FormatNode(formatSpec.format, formatSpec.segments));
         }
-
         everythingButFormats.forEach((node) => {
             const parent = this.getParentOf(node);
             if (node instanceof TextNode) {
                 // If this is a text node in an atom node we're not formatting the atom node's format, then just
                 // account for it's length, but do nothing else.
-                const atomAncestor = node.getClosestParentOfType(
-                    this,
-                    AtomNode
-                );
-                if (
-                    atomAncestor instanceof AtomNode &&
+                const atomAncestor = node.getClosestParentOfType(this, AtomNode);
+                if (atomAncestor instanceof AtomNode &&
                     atomAncestor.getMeta() !== this &&
-                    atomAncestor.getMeta() instanceof FormatNode
-                ) {
+                    atomAncestor.getMeta() instanceof FormatNode) {
                     textIndex += node.getCaretPositionCount();
-                } else if (parent instanceof FormatNode) {
+                }
+                else if (parent instanceof FormatNode) {
                     // Remember we found an empty node so that we don't insert an extra one later.
                     if (node.getText().length === 0) {
-                        if (
-                            textIndex === selectionStartIndex &&
-                            zeroWidthSelection
-                        ) {
+                        if (textIndex === selectionStartIndex &&
+                            zeroWidthSelection) {
                             formattingEmptyNode = true;
                             textIndex++;
                         }
-                    } else {
+                    }
+                    else {
                         // Process each character in the node, including the very last position.
                         for (let i = 0; i <= node.getText().length; i++) {
                             // Determine the desired format for this character. Start with the current formats
@@ -517,31 +398,22 @@ export default class FormatNode extends Node {
                             let desiredFormats = formatter
                                 ? formatter.getFormats(this)
                                 : [];
-                            if (
-                                format !== undefined &&
+                            if (format !== undefined &&
                                 ((textIndex === selectionStartIndex &&
                                     zeroWidthSelection) ||
-                                    inRange())
-                            ) {
+                                    inRange())) {
                                 // Remove all formatting if we were asked to.
-                                if (format === '') desiredFormats = [];
+                                if (format === '')
+                                    desiredFormats = [];
                                 // Apply the formatting if it's not already applied.
-                                else if (
-                                    !alreadyApplied &&
-                                    !desiredFormats.includes(format)
-                                )
+                                else if (!alreadyApplied &&
+                                    !desiredFormats.includes(format))
                                     desiredFormats.push(format);
                                 // Remove the formatting if it's already applied in the selection.
-                                else if (
-                                    alreadyApplied &&
-                                    desiredFormats.includes(format)
-                                )
-                                    desiredFormats.splice(
-                                        desiredFormats.indexOf(format),
-                                        1
-                                    );
+                                else if (alreadyApplied &&
+                                    desiredFormats.includes(format))
+                                    desiredFormats.splice(desiredFormats.indexOf(format), 1);
                             }
-
                             // Remove undesired formats.
                             getFormats().forEach((activeFormat) => {
                                 // If the current format is not in the desired list, close the text
@@ -549,22 +421,16 @@ export default class FormatNode extends Node {
                                 if (!desiredFormats.includes(activeFormat)) {
                                     // Save any text that we've accumulated.
                                     saveText();
-
                                     // Not sure this loop is necessary; we should always remove in the order we added.
-                                    while (
-                                        newFormats[0].format !== activeFormat
-                                    )
+                                    while (newFormats[0].format !== activeFormat)
                                         finishFormat();
                                     // Do it one more time to close out the undesired format.
                                     finishFormat();
-
                                     // If we have unformatted something at a zero-width range, create empty format node, add a text node in it and remember it so
                                     // we can place the caret in it.
-                                    if (
-                                        !formattingEmptyNode &&
+                                    if (!formattingEmptyNode &&
                                         textIndex === selectionStartIndex &&
-                                        zeroWidthSelection
-                                    ) {
+                                        zeroWidthSelection) {
                                         // Remember the node for later, so we can place the caret in it.
                                         emptyNode = new TextNode();
                                         // Append the empty node to the current format.
@@ -577,7 +443,6 @@ export default class FormatNode extends Node {
                                     }
                                 }
                             });
-
                             // Ensure the desired formats.
                             desiredFormats.forEach((desiredFormat) => {
                                 // If the current format does not yet include the desired format,
@@ -585,27 +450,22 @@ export default class FormatNode extends Node {
                                 if (!getFormats().includes(desiredFormat)) {
                                     // Save any text that we've accumulated in the curent format.
                                     saveText();
-
                                     // Add a new format onto the stack to start adding to.
                                     newFormats.unshift({
                                         format: desiredFormat,
                                         segments: [],
                                     });
-
                                     // If we inserted an empty format node, add a text node in it and remember it so
                                     // we can place the caret in it.
-                                    if (
-                                        !formattingEmptyNode &&
+                                    if (!formattingEmptyNode &&
                                         textIndex === selectionStartIndex &&
-                                        zeroWidthSelection
-                                    ) {
+                                        zeroWidthSelection) {
                                         emptyNode = new TextNode();
                                         newFormats[0].segments.push(emptyNode);
                                         finishFormat();
                                     }
                                 }
                             });
-
                             // If there's a format we're applying, or we're outside the deletion range, append the current character.
                             // We don't do this if we're checking the very last index of the node, since there is no character after it.
                             if (i < node.getLength()) {
@@ -621,20 +481,16 @@ export default class FormatNode extends Node {
                 else if (parent instanceof MetadataNode) {
                     // Save whatever text came before it.
                     saveText();
-
                     // Process each character in the node if we're formatting, and if we're deleting, skip anything in range of deletion.
                     for (let i = 0; i < node.getText().length; i++) {
                         if (format !== undefined || !inRange())
                             currentText += node.getText().charAt(i);
                         textIndex++;
                     }
-
                     // Duplicate the MetadataNode but with new text. Erase the MetadataNode if the text is empty
                     // by simply not adding one to this new format. Then, erase the text, since it was added in the metadata node.
                     if (currentText.length > 0) {
-                        newFormats[0].segments.push(
-                            parent.withText(new TextNode(currentText))
-                        );
+                        newFormats[0].segments.push(parent.withText(new TextNode(currentText)));
                         currentText = '';
                     }
                 }
@@ -644,52 +500,35 @@ export default class FormatNode extends Node {
             else if (node instanceof AtomNode) {
                 // Before adding the atom, create a text node and reset the accumulator.
                 saveText();
-
                 // Add the atom immediately after, unless it's in the deletion range.
                 // We include the start index since AtomNode's text index is on the left.
-                if (
-                    format !== undefined ||
+                if (format !== undefined ||
                     textIndex < selectionStartIndex ||
-                    textIndex > selectionEndIndex
-                ) {
+                    textIndex > selectionEndIndex) {
                     // Does the atom node have a format? Format it!
                     let newAtom = node;
                     const atomMeta = node.getMeta();
                     if (atomMeta instanceof FormatNode) {
-                        if (
-                            atomMeta.contains(range.start.node) &&
-                            atomMeta.contains(range.end.node)
-                        ) {
-                            const newFormat = atomMeta.withFormat(
-                                range,
-                                format
-                            );
+                        if (atomMeta.contains(range.start.node) &&
+                            atomMeta.contains(range.end.node)) {
+                            const newFormat = atomMeta.withFormat(range, format);
                             newAtom = node.withMeta(newFormat);
                         }
                     }
                     // Add the formatted atom if there is one.
-                    newFormats[0].segments.push(
-                        newAtom !== undefined ? newAtom : node
-                    );
+                    newFormats[0].segments.push(newAtom !== undefined ? newAtom : node);
                 }
-
                 // Increment the text index; atoms count for one character.
                 textIndex++;
             }
         });
-
         // Save any remaining text that we've accumulated.
         saveText();
-
         // Keep finishing formats until we get to the original we created.
-        while (newFormats.length > 1) finishFormat();
-
+        while (newFormats.length > 1)
+            finishFormat();
         // Create the final format.
-        let newFormat = new FormatNode(
-            newFormats[0].format,
-            newFormats[0].segments
-        );
-
+        let newFormat = new FormatNode(newFormats[0].format, newFormats[0].segments);
         // If after all that, it's empty, make sure there's one empty text node to type in.
         if (newFormat.getTextAndAtomNodes().length === 0)
             newFormat = new FormatNode('', [new TextNode()]);
@@ -697,230 +536,210 @@ export default class FormatNode extends Node {
         else {
             if (newFormat.#segments[0] instanceof AtomNode)
                 newFormat = newFormat.withSegmentPrepended(new TextNode());
-            if (
-                newFormat.#segments[newFormat.getLength() - 1] instanceof
-                AtomNode
-            )
+            if (newFormat.#segments[newFormat.getLength() - 1] instanceof
+                AtomNode)
                 newFormat = newFormat.withSegmentAppended(new TextNode());
         }
-
         return newFormat;
     }
-
-    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit {
+    withRangeFormatted(range, format) {
         // Convert the range to text indices.
         const text = caretRangeToIndexRange(this, range);
-        if (text === undefined) return;
+        if (text === undefined)
+            return;
         const newFormat = this.withFormat(range, format);
-        if (newFormat === undefined) return;
+        if (newFormat === undefined)
+            return;
         const newStart = indexToCaret(newFormat, text.start);
-        const newEnd =
-            format === undefined ? newStart : indexToCaret(newFormat, text.end);
-        if (newStart === undefined || newEnd === undefined) return;
+        const newEnd = format === undefined ? newStart : indexToCaret(newFormat, text.end);
+        if (newStart === undefined || newEnd === undefined)
+            return;
         return { root: newFormat, range: { start: newStart, end: newEnd } };
     }
-
-    getFormats(root: Node): Format[] {
-        let format: Node | undefined = this;
-        const formats: Format[] = [];
+    getFormats(root) {
+        let format = this;
+        const formats = [];
         while (format instanceof FormatNode) {
-            if (format.#format !== '') formats.push(format.#format);
+            if (format.#format !== '')
+                formats.push(format.#format);
             format = format.getParent(root);
         }
         return formats;
     }
-
-    withSegmentAt(
-        segment: FormatNodeSegmentType,
-        caret: Caret
-    ): FormatNode | undefined {
-        if (!(caret.node instanceof TextNode)) return;
-
+    withSegmentAt(segment, caret) {
+        if (!(caret.node instanceof TextNode))
+            return;
         // Verify that the caret's node is a segment in this node.
         const index = this.#segments.indexOf(caret.node);
-        if (index < 0) return;
-
+        if (index < 0)
+            return;
         // Splice the text node.
-        const left = new TextNode(
-            caret.node.getText().substring(0, caret.index)
-        );
+        const left = new TextNode(caret.node.getText().substring(0, caret.index));
         const right = new TextNode(caret.node.getText().substring(caret.index));
-
         // Insert the new left, right and middle
         const newSegments = this.#segments.slice();
         newSegments.splice(index, 1, left, segment, right);
         return new FormatNode(this.#format, newSegments);
     }
-
-    withSegmentAtSelection(
-        range: CaretRange,
-        nodeCreator: (text: string) => FormatNodeSegmentType
-    ): Edit {
+    withSegmentAtSelection(range, nodeCreator) {
         // If there's a selection, grab it's text and then remove the text and update the root and text being edited.
         let selectedText = this.getSelectedText(range);
-        let newFormat: FormatNode | undefined = this;
+        let newFormat = this;
         const sortedRange = this.sortRange(range);
         let caret = sortedRange.start;
-        if (
-            sortedRange.start.node !== sortedRange.end.node ||
-            sortedRange.start.index !== sortedRange.end.index
-        ) {
+        if (sortedRange.start.node !== sortedRange.end.node ||
+            sortedRange.start.index !== sortedRange.end.index) {
             // Try to remove the selected text. Bail on fail.
             const textIndex = caretToIndex(this, sortedRange.start);
-            if (textIndex === undefined) return;
+            if (textIndex === undefined)
+                return;
             newFormat = this.withoutRange(sortedRange);
-            if (newFormat === undefined) return;
+            if (newFormat === undefined)
+                return;
             const newCaret = indexToCaret(newFormat, textIndex);
-            if (newCaret === undefined) return;
+            if (newCaret === undefined)
+                return;
             caret = newCaret;
         }
-
         // Create and insert the into the formatted node.
-        const newNode = nodeCreator.call(
-            undefined,
-            selectedText ? selectedText : ''
-        );
+        const newNode = nodeCreator.call(undefined, selectedText ? selectedText : '');
         const revisedFormat = newFormat.withSegmentAt(newNode, caret);
-        if (revisedFormat === undefined) return;
-        const newCaret =
-            newNode instanceof AtomNode
-                ? newNode.getDefaultCaret()
-                : newNode instanceof FormatNode
+        if (revisedFormat === undefined)
+            return;
+        const newCaret = newNode instanceof AtomNode
+            ? newNode.getDefaultCaret()
+            : newNode instanceof FormatNode
                 ? newNode.getFirstCaret()
                 : newNode instanceof MetadataNode
-                ? { node: newNode.getText(), index: 0 }
-                : newNode instanceof TextNode
-                ? { node: newNode, index: 0 }
-                : undefined;
-
-        if (newCaret === undefined) return;
+                    ? { node: newNode.getText(), index: 0 }
+                    : newNode instanceof TextNode
+                        ? { node: newNode, index: 0 }
+                        : undefined;
+        if (newCaret === undefined)
+            return;
         return {
             root: revisedFormat,
             range: { start: newCaret, end: newCaret },
         };
     }
-
-    withoutContentBefore(caret: Caret): FormatNode | undefined {
+    withoutContentBefore(caret) {
         return this.withContentAt(caret, false);
     }
-
-    withoutContentAfter(caret: Caret): FormatNode | undefined {
+    withoutContentAfter(caret) {
         return this.withContentAt(caret, true);
     }
-
-    withContentAt(caret: Caret, before: boolean): FormatNode | undefined {
+    withContentAt(caret, before) {
         let range = undefined;
         if (before) {
             const lastCaret = this.getLastCaret();
-            if (lastCaret === undefined) return;
+            if (lastCaret === undefined)
+                return;
             range = { start: caret, end: lastCaret };
-        } else {
+        }
+        else {
             const firstCaret = this.getFirstCaret();
-            if (firstCaret === undefined) return;
+            if (firstCaret === undefined)
+                return;
             range = { start: firstCaret, end: caret };
         }
         return this.withoutRange(range);
     }
-
-    withContentInRange(range: CaretRange): this | undefined {
+    withContentInRange(range) {
         const containsStart = this.contains(range.start.node);
         const containsEnd = this.contains(range.end.node);
-        if (!containsStart && !containsEnd) return this.copy();
+        if (!containsStart && !containsEnd)
+            return this.copy();
         const startCaret = containsStart ? range.start : this.getFirstCaret();
         const endCaret = containsEnd ? range.end : this.getLastCaret();
-        if (startCaret === undefined || endCaret === undefined) return;
+        if (startCaret === undefined || endCaret === undefined)
+            return;
         const startIndex = caretToIndex(this, startCaret);
         const endIndex = caretToIndex(this, endCaret);
-        if (startIndex === undefined || endIndex === undefined) return;
+        if (startIndex === undefined || endIndex === undefined)
+            return;
         const withoutBefore = this.withoutContentBefore(startCaret);
-        if (withoutBefore === undefined) return;
-        const revisedEndCaret = indexToCaret(
-            withoutBefore,
-            endIndex - startIndex
-        );
-        if (revisedEndCaret === undefined) return;
-        return withoutBefore.withoutContentAfter(revisedEndCaret) as this;
-    }
-
-    withSegmentsAppended(format: FormatNode): FormatNode {
+        if (withoutBefore === undefined)
+            return;
+        const revisedEndCaret = indexToCaret(withoutBefore, endIndex - startIndex);
+        if (revisedEndCaret === undefined)
+            return;
+        return withoutBefore.withoutContentAfter(revisedEndCaret);
+    }
+    withSegmentsAppended(format) {
         return new FormatNode(this.#format, [
             ...this.#segments,
             ...format.getSegments(),
         ]);
     }
-
-    withoutAdjacentContent(caret: Caret, next: boolean): Edit | undefined {
+    withoutAdjacentContent(caret, next) {
         return this.withoutCharacter(caret, next);
     }
-
-    withoutCharacter(caret: Caret, next: boolean): Edit | undefined {
+    withoutCharacter(caret, next) {
         // Confirm that this caret is in this format.
-        if (!this.contains(caret.node)) return;
+        if (!this.contains(caret.node))
+            return;
         // Is there an adjascent caret? Return nothing if not.
         const adjacentCaret = this.getAdjacentCaret(caret, next);
-        if (adjacentCaret === undefined) return;
-
+        if (adjacentCaret === undefined)
+            return;
         // Handle each case differently
         if (caret.node instanceof AtomNode) {
             const newFormat = this.withNodeReplaced(caret.node, undefined);
-            if (newFormat === undefined) return;
+            if (newFormat === undefined)
+                return;
             return {
                 root: newFormat,
                 range: { start: adjacentCaret, end: adjacentCaret },
             };
-        } else if (adjacentCaret.node instanceof AtomNode) {
-            const newFormat = this.withNodeReplaced(
-                adjacentCaret.node,
-                undefined
-            );
-            if (newFormat === undefined) return;
+        }
+        else if (adjacentCaret.node instanceof AtomNode) {
+            const newFormat = this.withNodeReplaced(adjacentCaret.node, undefined);
+            if (newFormat === undefined)
+                return;
             return { root: newFormat, range: { start: caret, end: caret } };
-        } else {
+        }
+        else {
             // If next, keep the caret in place, otherwise go to the adjacent caret position.
             const textIndex = caretToIndex(this, next ? caret : adjacentCaret);
-            if (textIndex === undefined) return;
+            if (textIndex === undefined)
+                return;
             // If there is one, try removing everything between this and the adjascent caret.
             const newFormat = this.withoutRange({
                 start: caret,
                 end: adjacentCaret,
             });
-            if (newFormat === undefined) return;
+            if (newFormat === undefined)
+                return;
             const newCaret = indexToCaret(newFormat, textIndex);
-            if (newCaret === undefined) return;
+            if (newCaret === undefined)
+                return;
             return {
                 root: newFormat,
                 range: { start: newCaret, end: newCaret },
             };
         }
     }
-
-    withNodeInserted(caret: Caret, node: Node): Edit {
+    withNodeInserted(caret, node) {
         // The caret node has to be one of the nodes in this format to insert.
-        const index = this.#segments.indexOf(
-            caret.node as FormatNodeSegmentType
-        );
-        if (index < 0) return;
+        const index = this.#segments.indexOf(caret.node);
+        if (index < 0)
+            return;
         // The inserted node has to be a segment type.
-        if (
-            !(
-                node instanceof FormatNode ||
-                node instanceof TextNode ||
-                node instanceof MetadataNode ||
-                node instanceof AtomNode
-            )
-        )
+        if (!(node instanceof FormatNode ||
+            node instanceof TextNode ||
+            node instanceof MetadataNode ||
+            node instanceof AtomNode))
             return;
-
         const newFormat = this.withSegmentAt(node, caret);
-        const newCaret =
-            node instanceof AtomNode
-                ? node.getDefaultCaret()
-                : node instanceof FormatNode
+        const newCaret = node instanceof AtomNode
+            ? node.getDefaultCaret()
+            : node instanceof FormatNode
                 ? node.getLastCaret()
                 : node instanceof MetadataNode
-                ? { node: node.getText(), index: node.getText().getLength() }
-                : { node: node, index: node.getLength() };
-        if (newFormat === undefined || newCaret === undefined) return;
+                    ? { node: node.getText(), index: node.getText().getLength() }
+                    : { node: node, index: node.getLength() };
+        if (newFormat === undefined || newCaret === undefined)
+            return;
         return { root: newFormat, range: { start: newCaret, end: newCaret } };
     }
 }