bookish-press 0.4.0 → 0.4.3

package/models/chapter/FormatNode.js

@@ -1,8 +1,8 @@
-import Node from "./Node";
-import TextNode from "./TextNode";
-import { caretRangeToIndexRange, caretToIndex, indexToCaret } from "./Caret";
-import MetadataNode from "./MetadataNode";
-import AtomNode from "./AtomNode";
+import Node from './Node';
+import TextNode from './TextNode';
+import { caretRangeToIndexRange, caretToIndex, indexToCaret, } from './Caret';
+import MetadataNode from './MetadataNode';
+import AtomNode from './AtomNode';
 export default class FormatNode extends Node {
     #format;
     #segments;
@@ -11,42 +11,66 @@ export default class FormatNode extends Node {
         this.#format = format;
         // Remove consecutive empty text nodes.
         this.#segments = segments.filter((item, position, list) => {
-            if (position === 0 || !(item instanceof TextNode) || item.getLength() > 0)
+            if (position === 0 ||
+                !(item instanceof TextNode) ||
+                item.getLength() > 0)
                 return true;
             const previous = list[position - 1];
             return !(previous instanceof TextNode && previous.getLength() === 0);
         });
     }
-    getType() { return "formatted"; }
-    getFormat() { return this.#format; }
-    getSegments() { return this.#segments; }
-    isEmpty() { return this.#segments.length === 0; }
-    isEmptyText() { return this.#segments.length === 1 && this.#segments[0] instanceof TextNode && this.#segments[0].getText() === ""; }
-    getLength() { return this.#segments.length; }
+    getType() {
+        return 'formatted';
+    }
+    getFormat() {
+        return this.#format;
+    }
+    getSegments() {
+        return this.#segments;
+    }
+    isEmpty() {
+        return this.#segments.length === 0;
+    }
+    isEmptyText() {
+        return (this.#segments.length === 1 &&
+            this.#segments[0] instanceof TextNode &&
+            this.#segments[0].getText() === '');
+    }
+    getLength() {
+        return this.#segments.length;
+    }
     getParentOf(node) {
-        return this.#segments.map(b => b === node ? this : b.getParentOf(node)).find(b => b !== undefined);
+        return this.#segments
+            .map((b) => (b === node ? this : b.getParentOf(node)))
+            .find((b) => b !== undefined);
     }
     toText() {
-        return this.#segments.map(segment => segment.toText()).join(" ");
+        return this.#segments.map((segment) => segment.toText()).join(' ');
     }
     toHTML() {
         const format = this.#format;
-        const segments = this.#segments.map(s => s.toHTML()).join("");
-        if (format === "*")
+        const segments = this.#segments.map((s) => s.toHTML()).join('');
+        if (format === '*')
             return `<strong>${segments}</strong>`;
-        else if (format === "_")
+        else if (format === '_')
             return `<em>${segments}</em>`;
-        else if (format === "^")
+        else if (format === '^')
             return `<sup>${segments}</sup>`;
-        else if (format === "v")
+        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()).join("") + (this.#format === "v" ? "^" : this.#format);
+        return ((this.#format === 'v' ? '^v' : this.#format) +
+            this.#segments
+                .map((s) => s instanceof AtomNode ? s.toBookdown(this) : s.toBookdown())
+                .join('') +
+            (this.#format === 'v' ? '^' : this.#format));
+    }
+    getChildren() {
+        return this.#segments;
     }
-    getChildren() { return this.#segments; }
     getFirstTextNode() {
         const text = this.getTextNodes();
         return text[0];
@@ -56,27 +80,34 @@ export default class FormatNode extends Node {
         return text[text.length - 1];
     }
     copy() {
-        return new FormatNode(this.#format, this.#segments.map(s => s.copy()));
+        return new FormatNode(this.#format, this.#segments.map((s) => s.copy()));
     }
     getTextNodes() {
-        return this.getNodes().filter(n => n instanceof TextNode);
+        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() {
-        return this.getNodes().filter(n => (n instanceof TextNode || n instanceof AtomNode));
+        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 text = this.getTextAndAtomNodes().filter((n) => {
             const atomAncestor = n.getClosestParentOfType(this, AtomNode);
-            return atomAncestor === undefined || (atomAncestor instanceof AtomNode && atomAncestor.getMeta() === this);
+            return (atomAncestor === undefined ||
+                (atomAncestor instanceof AtomNode &&
+                    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));
+        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) {
         return this.getAdjacentTextOrAtom(node, true);
@@ -85,11 +116,14 @@ export default class FormatNode extends Node {
         return this.getAdjacentTextOrAtom(node, false);
     }
     getAdjacentCaret(caret, next) {
-        if (!(caret.node instanceof TextNode) && !(caret.node instanceof AtomNode))
+        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);
+            const adjacentText = next
+                ? caret.node.getNextCaret(caret.index)
+                : caret.node.getPreviousCaret(caret.index);
             if (adjacentText !== undefined)
                 return adjacentText;
         }
@@ -98,8 +132,19 @@ export default class FormatNode extends Node {
         if (adjacentNode !== undefined) {
             // Normally we skip over node boundaries because they look identical to each other.
             // But some nodes are zero length, so we have to account for that.
-            return { node: adjacentNode, index: next ? (adjacentNode instanceof TextNode ? (adjacentNode.isEmpty() ? 0 : 1) : 0) :
-                    (adjacentNode instanceof TextNode ? (adjacentNode.isEmpty() ? 0 : adjacentNode.getLength() - 1) : 0)
+            return {
+                node: adjacentNode,
+                index: next
+                    ? adjacentNode instanceof TextNode
+                        ? adjacentNode.isEmpty()
+                            ? 0
+                            : 1
+                        : 0
+                    : adjacentNode instanceof TextNode
+                        ? adjacentNode.isEmpty()
+                            ? 0
+                            : adjacentNode.getLength() - 1
+                        : 0,
             };
         }
         // Otherwise, there is no adjascent caret.
@@ -121,29 +166,42 @@ export default class FormatNode extends Node {
     getSelection() {
         const first = this.getFirstTextNode();
         const last = this.getLastTextNode();
-        return { start: { node: first, index: 0 }, end: { node: last, index: last.getLength() } };
+        return {
+            start: { node: first, index: 0 },
+            end: { node: last, index: last.getLength() },
+        };
     }
     getIndexOfTextNode(node) {
         const text = this.getTextNodes();
         return text.indexOf(node);
     }
     getSelectedText(range) {
-        if (!(range.start.node instanceof TextNode) || !(range.end.node instanceof TextNode))
+        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;
-        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 ? current.getText() :
-                    current === range.end.node ? current.getText().substring(0, range.end.index) :
-                        "";
-        }).join("");
-    }
-    withTextIfEmpty() { return this.isEmpty() ? this.withSegmentAppended(new TextNode()) : this; }
+        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
+                    ? current.getText()
+                    : current === range.end.node
+                        ? current.getText().substring(0, range.end.index)
+                        : '';
+        })
+            .join('');
+    }
+    withTextIfEmpty() {
+        return this.isEmpty() ? this.withSegmentAppended(new TextNode()) : this;
+    }
     withSegmentPrepended(segment) {
         return new FormatNode(this.#format, [segment, ...this.#segments]);
     }
@@ -167,16 +225,16 @@ export default class FormatNode extends Node {
         return new FormatNode(this.#format, newSegments);
     }
     withChildReplaced(node, replacement) {
-        return replacement === undefined ?
-            this.withoutSegment(node) :
-            this.withSegmentReplaced(node, replacement);
+        return replacement === undefined
+            ? this.withoutSegment(node)
+            : this.withSegmentReplaced(node, replacement);
     }
     // Creates two formatted nodes that split this node at the given caret location.
     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.        
+        // ... the caret is on a text node.
         if (!(caret.node instanceof TextNode) || !this.contains(caret.node))
             return undefined;
         const firstCaret = this.getFirstCaret();
@@ -197,21 +255,24 @@ export default class FormatNode extends Node {
     // It's approach is to scan through every text, meta, and atom node build a new format based on the requested format.
     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) ||
+        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.
@@ -224,25 +285,42 @@ export default class FormatNode extends Node {
         // 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 {
-            everythingButFormats.forEach(node => {
+            everythingButFormats.forEach((node) => {
                 const parent = this.getParentOf(node);
                 // If it's text, and the current position is in range of the selection, does the position contain the requested format?
                 if (node instanceof TextNode && parent instanceof FormatNode) {
                     // If we're formatting an empty node we previously found, this node's formatting is irrelevant.
-                    if (editingEmptyNode) { }
+                    if (editingEmptyNode) {
+                    }
                     // 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).includes(format);
+                            alreadyApplied = parent
+                                .getFormats(this)
+                                .includes(format);
                         }
                     }
                     // If this node has more than zero characters, the formatting is all applied if the selection contains the entirety of this node's text
                     // and this node's parent contains the formatting.
                     else {
-                        const parentIsFormatted = parent.getFormats(this).includes(format);
-                        const selectionContainsNode = (selectionStartIndex > checkIndex && selectionStartIndex < checkIndex + node.getCaretPositionCount() - 1) || (selectionEndIndex > checkIndex && selectionEndIndex < checkIndex + node.getCaretPositionCount() - 1);
-                        const nodeContainsSelection = selectionStartIndex >= checkIndex && selectionEndIndex <= checkIndex + node.getCaretPositionCount();
+                        const parentIsFormatted = parent
+                            .getFormats(this)
+                            .includes(format);
+                        const selectionContainsNode = (selectionStartIndex > checkIndex &&
+                            selectionStartIndex <
+                                checkIndex +
+                                    node.getCaretPositionCount() -
+                                    1) ||
+                            (selectionEndIndex > checkIndex &&
+                                selectionEndIndex <
+                                    checkIndex +
+                                        node.getCaretPositionCount() -
+                                        1);
+                        const nodeContainsSelection = selectionStartIndex >= checkIndex &&
+                            selectionEndIndex <=
+                                checkIndex + node.getCaretPositionCount();
                         checkIndex += node.getCaretPositionCount();
                         if (nodeContainsSelection || selectionContainsNode) {
                             nodeCount++;
@@ -260,45 +338,52 @@ export default class FormatNode extends Node {
         }
         // 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: "", 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 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) {
                 newFormats[0].segments.push(new TextNode(currentText));
-                currentText = "";
+                currentText = '';
             }
         }
         function inRange() {
-            return selectionStartIndex !== undefined && selectionEndIndex !== undefined && textIndex >= selectionStartIndex && textIndex < selectionEndIndex;
+            return (selectionStartIndex !== undefined &&
+                selectionEndIndex !== undefined &&
+                textIndex >= selectionStartIndex &&
+                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 !== "");
+            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))
+            if (formatSpec.segments.length > 0 ||
+                (zeroWidthSelection && textIndex === selectionStartIndex))
                 newFormats[0].segments.push(new FormatNode(formatSpec.format, formatSpec.segments));
         }
-        everythingButFormats.forEach(node => {
+        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 && atomAncestor.getMeta() !== this && atomAncestor.getMeta() instanceof FormatNode) {
+                if (atomAncestor instanceof AtomNode &&
+                    atomAncestor.getMeta() !== this &&
+                    atomAncestor.getMeta() instanceof FormatNode) {
                     textIndex += node.getCaretPositionCount();
                 }
                 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++;
                         }
@@ -307,24 +392,30 @@ export default class FormatNode extends Node {
                         // 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
-                            // and if we're in the selected range, adjust them accordingly based on the current formats 
+                            // and if we're in the selected range, adjust them accordingly based on the current formats
                             // and the requested format. (If this is a range deletion, then we just stick with the existing formats).
                             let formatter = node.getFormat(this);
-                            let desiredFormats = formatter ? formatter.getFormats(this) : [];
+                            let desiredFormats = formatter
+                                ? formatter.getFormats(this)
+                                : [];
                             if (format !== undefined &&
-                                ((textIndex === selectionStartIndex && zeroWidthSelection) || inRange())) {
+                                ((textIndex === selectionStartIndex &&
+                                    zeroWidthSelection) ||
+                                    inRange())) {
                                 // Remove all formatting if we were asked to.
-                                if (format === "")
+                                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))
+                                else if (alreadyApplied &&
+                                    desiredFormats.includes(format))
                                     desiredFormats.splice(desiredFormats.indexOf(format), 1);
                             }
                             // Remove undesired formats.
-                            getFormats().forEach(activeFormat => {
+                            getFormats().forEach((activeFormat) => {
                                 // If the current format is not in the desired list, close the text
                                 // node and keep popping formats until we find the parent of the offending format.
                                 if (!desiredFormats.includes(activeFormat)) {
@@ -337,28 +428,38 @@ export default class FormatNode extends Node {
                                     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 && textIndex === selectionStartIndex && zeroWidthSelection) {
+                                    if (!formattingEmptyNode &&
+                                        textIndex === selectionStartIndex &&
+                                        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.
                                         newFormats[0].segments.push(emptyNode);
                                         // Push a new format onto the stack to start adding to.
-                                        newFormats.unshift({ format: activeFormat, segments: [] });
+                                        newFormats.unshift({
+                                            format: activeFormat,
+                                            segments: [],
+                                        });
                                     }
                                 }
                             });
                             // Ensure the desired formats.
-                            desiredFormats.forEach(desiredFormat => {
+                            desiredFormats.forEach((desiredFormat) => {
                                 // If the current format does not yet include the desired format,
                                 // close the text node and start a new format.
                                 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: [] });
+                                    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 && textIndex === selectionStartIndex && zeroWidthSelection) {
+                                    if (!formattingEmptyNode &&
+                                        textIndex === selectionStartIndex &&
+                                        zeroWidthSelection) {
                                         emptyNode = new TextNode();
                                         newFormats[0].segments.push(emptyNode);
                                         finishFormat();
@@ -390,7 +491,7 @@ export default class FormatNode extends Node {
                     // 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)));
-                        currentText = "";
+                        currentText = '';
                     }
                 }
             }
@@ -401,12 +502,15 @@ export default class FormatNode extends Node {
                 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 || textIndex < selectionStartIndex || textIndex > selectionEndIndex) {
+                if (format !== undefined ||
+                    textIndex < selectionStartIndex ||
+                    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)) {
+                        if (atomMeta.contains(range.start.node) &&
+                            atomMeta.contains(range.end.node)) {
                             const newFormat = atomMeta.withFormat(range, format);
                             newAtom = node.withMeta(newFormat);
                         }
@@ -427,12 +531,13 @@ export default class FormatNode extends Node {
         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()]);
+            newFormat = new FormatNode('', [new TextNode()]);
         // If it starts or ends with an atom, insert an empty node so that text can be inserted before or after.
         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;
@@ -455,7 +560,7 @@ export default class FormatNode extends Node {
         let format = this;
         const formats = [];
         while (format instanceof FormatNode) {
-            if (format.#format !== "")
+            if (format.#format !== '')
                 formats.push(format.#format);
             format = format.getParent(root);
         }
@@ -482,7 +587,8 @@ export default class FormatNode extends Node {
         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)
@@ -496,18 +602,25 @@ export default class FormatNode extends Node {
             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 ? newNode.getFirstCaret() :
-                newNode instanceof MetadataNode ? { node: newNode.getText(), index: 0 } :
-                    newNode instanceof TextNode ? { node: newNode, index: 0 } :
-                        undefined;
+        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;
-        return { root: revisedFormat, range: { start: newCaret, end: newCaret } };
+        return {
+            root: revisedFormat,
+            range: { start: newCaret, end: newCaret },
+        };
     }
     withoutContentBefore(caret) {
         return this.withContentAt(caret, false);
@@ -547,13 +660,16 @@ export default class FormatNode extends Node {
         const withoutBefore = this.withoutContentBefore(startCaret);
         if (withoutBefore === undefined)
             return;
-        const revisedEndCaret = indexToCaret(withoutBefore, (endIndex - startIndex));
+        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()]);
+        return new FormatNode(this.#format, [
+            ...this.#segments,
+            ...format.getSegments(),
+        ]);
     }
     withoutAdjacentContent(caret, next) {
         return this.withoutCharacter(caret, next);
@@ -571,7 +687,10 @@ export default class FormatNode extends Node {
             const newFormat = this.withNodeReplaced(caret.node, undefined);
             if (newFormat === undefined)
                 return;
-            return { root: newFormat, range: { start: adjacentCaret, end: adjacentCaret } };
+            return {
+                root: newFormat,
+                range: { start: adjacentCaret, end: adjacentCaret },
+            };
         }
         else if (adjacentCaret.node instanceof AtomNode) {
             const newFormat = this.withNodeReplaced(adjacentCaret.node, undefined);
@@ -585,13 +704,19 @@ export default class FormatNode extends Node {
             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 });
+            const newFormat = this.withoutRange({
+                start: caret,
+                end: adjacentCaret,
+            });
             if (newFormat === undefined)
                 return;
             const newCaret = indexToCaret(newFormat, textIndex);
             if (newCaret === undefined)
                 return;
-            return { root: newFormat, range: { start: newCaret, end: newCaret } };
+            return {
+                root: newFormat,
+                range: { start: newCaret, end: newCaret },
+            };
         }
     }
     withNodeInserted(caret, node) {
@@ -600,13 +725,19 @@ export default class FormatNode extends 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 ? node.getLastCaret() :
-                node instanceof MetadataNode ? { node: node.getText(), index: node.getText().getLength() } :
-                    { node: node, index: node.getLength() };
+        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;
         return { root: newFormat, range: { start: newCaret, end: newCaret } };