bookish-press 0.4.0 → 0.4.16

package/models/chapter/BlocksNode.js

@@ -1,38 +1,50 @@
-import BlockNode from "./BlockNode";
-import ListNode from "./ListNode";
-import { caretToIndex, indexToCaret } from "./Caret";
-import ParagraphNode from "./ParagraphNode";
-import FormatNode from "./FormatNode";
-import TextNode from "./TextNode";
-import AtomNode from "./AtomNode";
-import CodeNode from "./CodeNode";
+import BlockNode from './BlockNode';
+import ListNode from './ListNode';
+import { caretToIndex, indexToCaret } from './Caret';
+import ParagraphNode from './ParagraphNode';
+import FormatNode from './FormatNode';
+import TextNode from './TextNode';
+import AtomNode from './AtomNode';
+import CodeNode from './CodeNode';
+import EmbedNode from './EmbedNode';
 export default class BlocksNode extends BlockNode {
     #blocks;
     constructor(elements) {
         super();
-        // Always ensure there's an empty paragraph before and after non-paragraph nodes to allow for insertions.
         const adjustedElements = [];
         for (let i = 0; i < elements.length; i++) {
             const block = elements[i];
             const previousBlock = i === 0 ? undefined : elements[i - 1];
             // If this block and the previous one are lists of the same kind, merge them.
-            if (block instanceof ListNode && previousBlock instanceof ListNode && block.isNumbered() === previousBlock.isNumbered()) {
-                adjustedElements[adjustedElements.length - 1] = previousBlock.withListAppended(block);
+            if (block instanceof ListNode &&
+                previousBlock instanceof ListNode &&
+                block.isNumbered() === previousBlock.isNumbered()) {
+                adjustedElements[adjustedElements.length - 1] =
+                    previousBlock.withListAppended(block);
             }
-            // If the block isn't a paragraph and the last one isn't either or this is the first one., put a paragraph between them to allow for insertion.
-            else {
-                if (!(block instanceof ParagraphNode) && (i === 0 || !(previousBlock instanceof ParagraphNode)))
-                    adjustedElements.push(new ParagraphNode());
+            // Always ensure there's an empty paragraph before and after non-paragraph nodes to allow for insertions.
+            // // If the block isn't a paragraph and the last one isn't either or this is the first one, put a paragraph between them to allow for insertion.
+            // else {
+            //     if(!(block instanceof ParagraphNode) && (i === 0 || !(previousBlock instanceof ParagraphNode)))
+            //         adjustedElements.push(new ParagraphNode());
+            // }
+            else
                 adjustedElements.push(block);
-            }
         }
         // Check the last one.
-        if (!(adjustedElements[adjustedElements.length - 1] instanceof ParagraphNode))
-            adjustedElements.push(new ParagraphNode());
+        // if(!(adjustedElements[adjustedElements.length - 1] instanceof ParagraphNode))
+        //     adjustedElements.push(new ParagraphNode());
         this.#blocks = adjustedElements;
+        // After all that, always ensure there's at least one empty paragraph block.
+        if (this.#blocks.length === 0)
+            this.#blocks.push(new ParagraphNode());
+    }
+    getBlocks() {
+        return this.#blocks;
+    }
+    getFormats() {
+        return this.getBlocks().reduce((prev, current) => prev.concat(current.getFormats()), []);
     }
-    getBlocks() { return this.#blocks; }
-    getFormats() { return this.getBlocks().reduce((prev, current) => prev.concat(current.getFormats()), []); }
     getIndexOf(block) {
         const index = this.#blocks.indexOf(block);
         return index < 0 ? undefined : index;
@@ -77,14 +89,18 @@ export default class BlocksNode extends BlockNode {
     getBlocksInRange(range) {
         // Find the start and end block the carets reside in. Bail on fail.
         const startBlock = this.getBlockOfCaret(range.start);
-        const endBlock = range.end === range.start ? startBlock : this.getBlockOfCaret(range.end);
+        const endBlock = range.end === range.start
+            ? startBlock
+            : this.getBlockOfCaret(range.end);
         if (startBlock === undefined || endBlock === undefined)
             return;
         // Find all of the blocks between the start and end blocks.
         // Start tracking when we hit the start node. Stop tracking when we hit the end node.
         const blocksToEdit = [];
         let insideSelection = false;
-        this.getNodes().filter(n => n instanceof BlockNode).forEach(node => {
+        this.getNodes()
+            .filter((n) => n instanceof BlockNode)
+            .forEach((node) => {
             if (node === startBlock)
                 insideSelection = true;
             if (insideSelection && node instanceof BlockNode)
@@ -98,16 +114,18 @@ export default class BlocksNode extends BlockNode {
         return caret.node.getClosestParentOfType(this, BlockNode);
     }
     getParentOf(node) {
-        return this.#blocks.map(b => b === node ? this : b.getParentOf(node)).find(b => b !== undefined);
+        return this.#blocks
+            .map((b) => (b === node ? this : b.getParentOf(node)))
+            .find((b) => b !== undefined);
     }
     getTextNodes() {
-        return this.getNodes().filter(node => node instanceof TextNode);
+        return this.getNodes().filter((node) => node instanceof TextNode);
     }
     getAtomNodes() {
-        return this.getNodes().filter(node => node instanceof AtomNode);
+        return this.getNodes().filter((node) => node instanceof AtomNode);
     }
     getTextAndAtomNodes() {
-        return this.getNodes().filter(node => node instanceof TextNode || node instanceof AtomNode);
+        return this.getNodes().filter((node) => node instanceof TextNode || node instanceof AtomNode);
     }
     getIndexOfTextNode(node) {
         const text = this.getTextNodes();
@@ -119,23 +137,30 @@ export default class BlocksNode extends BlockNode {
     }
     getLastCaret() {
         const text = this.getTextNodes();
-        return text.length === 0 ? undefined : { node: text[text.length - 1], index: text[text.length - 1].getLength() };
+        return text.length === 0
+            ? undefined
+            : {
+                node: text[text.length - 1],
+                index: text[text.length - 1].getLength(),
+            };
     }
     getAdjacentCaret(caret, next) {
         if (!this.contains(caret.node))
             return;
         // Navigate from code node.
-        const code = caret.node.getFarthestParentMatching(this, n => n instanceof CodeNode);
+        const code = caret.node.getFarthestParentMatching(this, (n) => n instanceof CodeNode);
         if (code && caret.node === code.getCodeNode()) {
             // Get the adjacent text node.
-            const newCaret = next ? caret.node.getNextCaret(caret.index) : caret.node.getPreviousCaret(caret.index);
+            const newCaret = next
+                ? caret.node.getNextCaret(caret.index)
+                : caret.node.getPreviousCaret(caret.index);
             if (newCaret !== undefined)
                 return newCaret;
             // Otherwise, get the adjacent format's first/last caret.
             if (next)
                 return code.getCaption().getFirstCaret();
             // If there's no adjacent caret, find the adjacent root format.
-            const blocks = this.getNodes().filter(n => n instanceof BlockNode);
+            const blocks = this.getNodes().filter((n) => n instanceof BlockNode);
             const codeIndex = blocks.indexOf(code);
             if (codeIndex <= 0)
                 return;
@@ -144,7 +169,7 @@ export default class BlocksNode extends BlockNode {
             const adjacentFormat = adjacentFormats[adjacentFormats.length - 1];
             return adjacentFormat.getLastCaret();
         }
-        const format = caret.node.getFarthestParentMatching(this, n => n instanceof FormatNode);
+        const format = caret.node.getFarthestParentMatching(this, (n) => n instanceof FormatNode);
         if (format === undefined)
             return;
         // Find the format that contains the caret and return the adjacent caret if there is one.
@@ -152,26 +177,34 @@ export default class BlocksNode extends BlockNode {
         if (adjacentCaretInFormat !== undefined)
             return adjacentCaretInFormat;
         // If there's no adjacent caret in the root format, find the adjacent format or code.
-        const formats = this.getNodes().filter(n => {
+        const formats = this.getNodes().filter((n) => {
             const parent = n.getParent(this);
-            return (n instanceof TextNode && parent instanceof CodeNode) || (n instanceof FormatNode && !(parent instanceof AtomNode) && !(parent instanceof FormatNode));
+            return ((n instanceof TextNode && parent instanceof CodeNode) ||
+                (n instanceof FormatNode &&
+                    !(parent instanceof AtomNode) &&
+                    !(parent instanceof FormatNode)));
         });
         const index = formats.indexOf(format);
-        const adjacentFormat = index < 0 || formats.length === 0 ? undefined : formats[index + (next ? 1 : -1)];
+        const adjacentFormat = index < 0 || formats.length === 0
+            ? undefined
+            : formats[index + (next ? 1 : -1)];
         if (adjacentFormat === undefined)
             return;
-        return next ? adjacentFormat.getFirstCaret() : adjacentFormat.getLastCaret();
+        return next
+            ? adjacentFormat.getFirstCaret()
+            : adjacentFormat.getLastCaret();
     }
     getSelectedFormatRange(format, range) {
         // Find all of the formats.
-        const formats = this.getNodes().filter(n => n instanceof FormatNode && !(this.getParentOf(n) instanceof FormatNode));
+        const formats = this.getNodes().filter((n) => n instanceof FormatNode &&
+            !(this.getParentOf(n) instanceof FormatNode));
         // Find the given format index.
         const formatIndex = formats.indexOf(format);
         if (formatIndex < 0)
             return undefined;
         // Find the range start and end formats.
-        const startFormat = formats.find(f => f.contains(range.start.node));
-        const endFormat = formats.find(f => f.contains(range.end.node));
+        const startFormat = formats.find((f) => f.contains(range.start.node));
+        const endFormat = formats.find((f) => f.contains(range.end.node));
         if (startFormat === undefined || endFormat === undefined)
             return undefined;
         const startIndex = formats.indexOf(startFormat);
@@ -225,7 +258,7 @@ export default class BlocksNode extends BlockNode {
         return this.create(newBlocks);
     }
     withoutBlock(block) {
-        return this.create(this.#blocks.filter(n => n !== block));
+        return this.create(this.#blocks.filter((n) => n !== block));
     }
     withBlockInsertedBefore(anchor, block) {
         return this.withBlockInserted(anchor, block, true);
@@ -237,48 +270,71 @@ export default class BlocksNode extends BlockNode {
         let caret = range.start;
         let blocks = this;
         // If there's a selection, remove it before inserting.
-        if (range.start.node !== range.end.node || range.start.index !== range.end.index) {
+        if (range.start.node !== range.end.node ||
+            range.start.index !== range.end.index) {
             const edit = blocks.withoutRange(range);
             if (edit === undefined || !(edit.root instanceof BlocksNode))
                 return;
             blocks = edit.root;
             caret = edit.range.start;
         }
-        // Find what paragraph the caret is in.
-        // There are some contexts with no paragraphs. Return the start range given.
-        const paragraph = caret.node.getClosestParentOfType(blocks, ParagraphNode);
-        if (paragraph === undefined)
-            return;
-        // Split the paragraph in two.
-        const split = paragraph.split(caret);
-        if (split === undefined)
+        // Find what block the caret is in.
+        const block = caret.node.getClosestParentOfType(blocks, BlockNode);
+        if (block === undefined)
             return;
-        const [first, last] = split;
-        const newCaret = last.getFirstCaret();
-        if (newCaret === undefined)
-            return;
-        // Find the paragraph's blocks node.
-        const paragraphBlocks = paragraph.getParent(blocks);
-        if (!(paragraphBlocks instanceof BlocksNode))
-            return;
-        const newBlocks = paragraphBlocks
-            .withBlockInsertedBefore(paragraph, first)
-            ?.withBlockInsertedAfter(paragraph, last)
-            ?.withoutBlock(paragraph);
-        if (newBlocks === undefined)
-            return;
-        // Replace the paragraphs blocks in these blocks.
-        const newRoot = blocks.withNodeReplaced(paragraphBlocks, newBlocks);
-        if (newRoot === undefined)
-            return;
-        return { root: newRoot, range: { start: newCaret, end: newCaret } };
+        // If it's a paragraph, split it.
+        if (block instanceof ParagraphNode) {
+            const paragraph = block;
+            // Split the paragraph in two.
+            const split = paragraph.split(caret);
+            if (split === undefined)
+                return;
+            const [first, last] = split;
+            const newCaret = last.getFirstCaret();
+            if (newCaret === undefined)
+                return;
+            // Find the paragraph's blocks node.
+            const paragraphBlocks = paragraph.getParent(blocks);
+            if (!(paragraphBlocks instanceof BlocksNode))
+                return;
+            const newBlocks = paragraphBlocks
+                .withBlockInsertedBefore(paragraph, first)
+                ?.withBlockInsertedAfter(paragraph, last)
+                ?.withoutBlock(paragraph);
+            if (newBlocks === undefined)
+                return;
+            // Replace the paragraphs blocks in these blocks.
+            const newRoot = blocks.withNodeReplaced(paragraphBlocks, newBlocks);
+            if (newRoot === undefined)
+                return;
+            return { root: newRoot, range: { start: newCaret, end: newCaret } };
+        }
+        // If any other kind of block, and an empty paragraph after the block.
+        else {
+            // Find the paragraph's blocks node.
+            const container = block.getParent(blocks);
+            if (!(container instanceof BlocksNode))
+                return;
+            const newParagraph = new ParagraphNode();
+            const newCaret = newParagraph.getFirstCaret();
+            if (newCaret === undefined)
+                return;
+            const newBlocks = container.withBlockInsertedAfter(block, newParagraph);
+            if (newBlocks === undefined)
+                return;
+            // Replace the paragraphs blocks in these blocks.
+            const newRoot = blocks.withNodeReplaced(container, newBlocks);
+            if (newRoot === undefined)
+                return;
+            return { root: newRoot, range: { start: newCaret, end: newCaret } };
+        }
     }
     withoutRange(range) {
         return this.withRangeFormatted(range, undefined);
     }
     withoutAtom(atom) {
         // Find the format that contains the atom.
-        const format = atom.getFarthestParentMatching(this, p => p instanceof FormatNode);
+        const format = atom.getFarthestParentMatching(this, (p) => p instanceof FormatNode);
         if (format === undefined)
             return;
         // Find the text or atom node to the left and right of the atom to determine the new caret position.
@@ -286,11 +342,16 @@ export default class BlocksNode extends BlockNode {
         const next = format.getNextTextOrAtom(atom);
         const newText = new TextNode();
         // If the format is otherwise empty, replace the atom with an empty text node
-        const newFormat = previous === undefined && next == undefined ?
-            format.withSegmentReplaced(atom, newText) :
-            format.withoutSegment(atom);
+        const newFormat = previous === undefined && next == undefined
+            ? format.withSegmentReplaced(atom, newText)
+            : format.withoutSegment(atom);
         // New caret is left, or right, or empty text.
-        const newCaret = { node: previous ? previous : next ? next : newText, index: previous && previous instanceof TextNode ? previous.getLength() : 0 };
+        const newCaret = {
+            node: previous ? previous : next ? next : newText,
+            index: previous && previous instanceof TextNode
+                ? previous.getLength()
+                : 0,
+        };
         // No format? Fail.
         if (newFormat === undefined)
             return;
@@ -303,18 +364,27 @@ export default class BlocksNode extends BlockNode {
     }
     withRangeFormatted(range, format) {
         // Only works on text nodes, atom nodes, and metadata nodes.
-        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))
             return;
         // Have we selected a single atom node for removal? Remove it and place the caret in the adjacent word.
-        if (format === undefined && (range.start.node instanceof AtomNode && range.end.node instanceof AtomNode && range.start.node === range.end.node)) {
+        if (format === undefined &&
+            range.start.node instanceof AtomNode &&
+            range.end.node instanceof AtomNode &&
+            range.start.node === range.end.node) {
             return this.withoutAtom(range.start.node);
         }
         // Preserve the original range, since there are a few cases where we adjust it.
         let adjustedRange = range;
         // If this a single point in format, and we're clearing formatting, adjust the selection to the whole format.
-        if (format === "" && range.start.node === range.end.node && range.start.index === range.end.index) {
-            const selection = range.start.node.getFormatRoot(this)?.getSelection();
+        if (format === '' &&
+            range.start.node === range.end.node &&
+            range.start.index === range.end.index) {
+            const selection = range.start.node
+                .getFormatRoot(this)
+                ?.getSelection();
             if (selection === undefined)
                 return;
             adjustedRange = selection;
@@ -337,8 +407,12 @@ export default class BlocksNode extends BlockNode {
             if (containsStart || containsEnd || inRange) {
                 inRange = true;
                 // Compute a proper range based on containment.
-                const blockStart = containsStart ? sortedRange.start : block.getFirstCaret();
-                const blockEnd = containsEnd ? sortedRange.end : block.getLastCaret();
+                const blockStart = containsStart
+                    ? sortedRange.start
+                    : block.getFirstCaret();
+                const blockEnd = containsEnd
+                    ? sortedRange.end
+                    : block.getLastCaret();
                 if (blockStart === undefined || blockEnd === undefined)
                     return;
                 // If we're just going to delete it, then don't bother formatting it.
@@ -354,16 +428,40 @@ export default class BlocksNode extends BlockNode {
                     if (edit === undefined)
                         return;
                     // If we succeeded in formatting it, replace it, otherwise skip it.
+                    let newBlock = edit.root;
+                    // Finally, if the selection started before a list node, and we were deleting in the middle of some item,
+                    // convert that item (which should now be the first item in the list) into a paragraph, since it's bullet was deleted, conceptually.
+                    if (!newBlock.isEmpty() &&
+                        newBlock instanceof ListNode &&
+                        !containsStart &&
+                        containsEnd) {
+                        const firstItem = newBlock.getItem(0);
+                        if (firstItem instanceof FormatNode) {
+                            // Remove the item from the list.
+                            const newListWithoutItem = newBlock.withoutItem(firstItem);
+                            if (newListWithoutItem === undefined)
+                                return;
+                            newBlock = newListWithoutItem;
+                            // Replace the revised list
+                            const blocksWithList = newBlocks
+                                .withChildReplaced(block, newBlock)
+                                ?.withBlockInsertedBefore(newBlock, new ParagraphNode(0, firstItem));
+                            if (blocksWithList === undefined)
+                                return;
+                            newBlocks = blocksWithList;
+                        }
+                    }
+                    // Otherwise, just handle the new block in isolation.
                     else {
-                        const newBlock = edit.root;
                         // Remember non-empty revised blocks so we can merge things after.
                         if (!newBlock.isEmpty())
                             formattedBlocks.push(newBlock);
                         // Replace the block, or delete it if it's empty.
                         newBlocks = newBlocks.withChildReplaced(block, newBlock.isEmpty() ? undefined : newBlock);
-                        if (newBlocks === undefined)
-                            return;
                     }
+                    // If we failed to replace it, bail.
+                    if (newBlocks === undefined)
+                        return;
                 }
             }
             if (block.contains(sortedRange.end.node))
@@ -373,7 +471,8 @@ export default class BlocksNode extends BlockNode {
         if (format === undefined && formattedBlocks.length >= 2) {
             const first = formattedBlocks[0];
             const last = formattedBlocks[formattedBlocks.length - 1];
-            if (first instanceof ParagraphNode && last instanceof ParagraphNode) {
+            if (first instanceof ParagraphNode &&
+                last instanceof ParagraphNode) {
                 // Replace the first paragraph with the second merged.
                 newBlocks = newBlocks.withNodeReplaced(first, first.withContent(first.getFormat().withSegmentsAppended(last.getFormat())));
                 if (newBlocks === undefined)
@@ -386,7 +485,9 @@ export default class BlocksNode extends BlockNode {
         }
         const startCaret = indexToCaret(newBlocks, startTextIndex);
         // If we deleted, then the end caret should be the same as the start.
-        const endCaret = format === undefined ? startCaret : indexToCaret(newBlocks, endTextIndex);
+        const endCaret = format === undefined
+            ? startCaret
+            : indexToCaret(newBlocks, endTextIndex);
         if (startCaret === undefined || endCaret === undefined)
             return;
         // Return the new root and the start and end of the range.
@@ -417,13 +518,14 @@ export default class BlocksNode extends BlockNode {
         if (blocksInRange === undefined)
             return;
         // Only format if every block selected is a paragraph node. Non-paragraphs can't be in lists.
-        if (!blocksInRange.every(b => b instanceof ParagraphNode))
+        if (!blocksInRange.every((b) => b instanceof ParagraphNode))
             return;
         // Split the blocks into groups with shared parents.
         const sequences = [[]];
         let previous = undefined;
-        blocksInRange.forEach(block => {
-            if (previous === undefined || block.getParent(this) === previous.getParent(this))
+        blocksInRange.forEach((block) => {
+            if (previous === undefined ||
+                block.getParent(this) === previous.getParent(this))
                 sequences[sequences.length - 1].push(block);
             else {
                 sequences.push([block]);
@@ -435,7 +537,7 @@ export default class BlocksNode extends BlockNode {
         for (let i = 0; i < sequences.length; i++) {
             const sequence = sequences[i];
             // Make the new list
-            const newList = new ListNode(sequence.map(p => p.getFormat()), numbered);
+            const newList = new ListNode(sequence.map((p) => p.getFormat()), numbered);
             // Insert the new list
             const blocksParent = sequence[0].getParent(newBlocks);
             if (blocksParent === undefined)
@@ -462,14 +564,23 @@ export default class BlocksNode extends BlockNode {
         if (blocksInRange === undefined)
             return;
         // Convert all of the lists into their root lists, since we only convert entire lists, not parts of lists.
-        const listsInRange = blocksInRange.filter(l => l instanceof ListNode);
-        const listRootsInRange = [...new Set(listsInRange.map(l => l.getParent(this) instanceof ListNode ? l.getFarthestParentMatching(this, m => m instanceof ListNode) : l).filter(n => n !== undefined))];
+        const listsInRange = blocksInRange.filter((l) => l instanceof ListNode);
+        const listRootsInRange = [
+            ...new Set(listsInRange
+                .map((l) => l.getParent(this) instanceof ListNode
+                ? l.getFarthestParentMatching(this, (m) => m instanceof ListNode)
+                : l)
+                .filter((n) => n !== undefined)),
+        ];
         if (listRootsInRange.length === 0)
             return undefined;
         // For each list in the range, convert all items in range to paragraphs.
         for (let i = 0; i < listRootsInRange.length; i++) {
             const list = listRootsInRange[i];
-            const paragraphs = list.getNodes().filter(n => n instanceof FormatNode).map(f => new ParagraphNode(0, f));
+            const paragraphs = list
+                .getNodes()
+                .filter((n) => n instanceof FormatNode)
+                .map((f) => new ParagraphNode(0, f));
             // Insert in reverse order to keep them in order, since the list is our anchor.
             for (let j = paragraphs.length - 1; j >= 0; j--) {
                 const paragraph = paragraphs[j];
@@ -490,10 +601,13 @@ export default class BlocksNode extends BlockNode {
         // Find all of the formats in list nodes in the range and indent them.
         const ancestor = range.start.node.getCommonAncestor(newBlocks, range.end.node);
         const nodes = ancestor?.getNodes();
-        const formats = nodes?.filter(n => n instanceof FormatNode && newBlocks.getParentOf(n) instanceof ListNode);
+        const formats = nodes?.filter((n) => n instanceof FormatNode &&
+            newBlocks.getParentOf(n) instanceof ListNode);
         const startIndex = nodes?.indexOf(range.start.node);
         const endIndex = nodes?.indexOf(range.end.node);
-        if (formats === undefined || startIndex === undefined || endIndex === undefined)
+        if (formats === undefined ||
+            startIndex === undefined ||
+            endIndex === undefined)
             return;
         // Loop through the formats in the range and indent or dedent them, constructing a new root.
         const first = startIndex < endIndex ? range.start.node : range.end.node;
@@ -506,9 +620,11 @@ export default class BlocksNode extends BlockNode {
             // If we're in the selection and the format is in a list, restructure it's list to indent/unindent it.
             if (inside) {
                 // Find the root list node of the format.
-                const list = format.getFarthestParentMatching(newBlocks, n => n instanceof ListNode);
+                const list = format.getFarthestParentMatching(newBlocks, (n) => n instanceof ListNode);
                 if (list instanceof ListNode) {
-                    const newList = indent ? list.withItemIndented(format) : list.withItemUnindented(format);
+                    const newList = indent
+                        ? list.withItemIndented(format)
+                        : list.withItemUnindented(format);
                     if (newList === undefined)
                         return;
                     const blocksWithIndent = newBlocks.withChildReplaced(list, newList);
@@ -534,6 +650,7 @@ export default class BlocksNode extends BlockNode {
             return;
         // Find the parents of the node.
         const parents = this.getParentsOf(caret.node);
+        // Iterate through the ancestors, seeing if they'd like to handle the request for a deletion.
         while (parents && parents.length > 0) {
             const parent = parents.pop();
             // Ask the format node it's in to edit it, and return if successful.
@@ -547,6 +664,32 @@ export default class BlocksNode extends BlockNode {
                     return { root: newBlocks, range: editedFormat.range };
                 }
             }
+            // See if the CodeNode would like to handle it.
+            else if (parent instanceof CodeNode) {
+                const revisedCode = parent.getCodeNode().withoutRange({
+                    start: caret,
+                    end: {
+                        node: caret.node,
+                        index: caret.index + (next ? 1 : -1),
+                    },
+                });
+                if (revisedCode === undefined)
+                    return;
+                const revisedCodeNode = parent.withChildReplaced(parent.getCodeNode(), revisedCode);
+                if (revisedCodeNode === undefined)
+                    return;
+                const newBlocks = this.withNodeReplaced(parent, revisedCodeNode);
+                const newCaret = {
+                    node: revisedCode,
+                    index: Math.max(0, caret.index + (next ? 0 : -1)),
+                };
+                return newBlocks === undefined
+                    ? undefined
+                    : {
+                        root: newBlocks,
+                        range: { start: newCaret, end: newCaret },
+                    };
+            }
             // If it's a format in the list node, merge with the previous list item
             else if (parent instanceof ListNode) {
                 const index = parent.getItemContaining(caret);
@@ -561,10 +704,14 @@ export default class BlocksNode extends BlockNode {
                     const newBlocks = this.withNodeReplaced(parent, newList);
                     if (newBlocks === undefined)
                         return;
-                    return { root: newBlocks, range: { start: newCaret, end: newCaret } };
+                    return {
+                        root: newBlocks,
+                        range: { start: newCaret, end: newCaret },
+                    };
                 }
                 // Convert the remaining list item into a paragraph.
-                else if (parents.length > 0 && parents[parents.length - 1] instanceof BlocksNode) {
+                else if (parents.length > 0 &&
+                    parents[parents.length - 1] instanceof BlocksNode) {
                     const item = parent.getItem(0);
                     if (!(item instanceof FormatNode))
                         return;
@@ -573,36 +720,56 @@ export default class BlocksNode extends BlockNode {
                     const newCaret = newParagraph.getFirstCaret();
                     if (newBlocks === undefined || newCaret === undefined)
                         return;
-                    return { root: newBlocks, range: { start: newCaret, end: newCaret } };
+                    return {
+                        root: newBlocks,
+                        range: { start: newCaret, end: newCaret },
+                    };
                 }
             }
             // If it's at the beginning of the paragraph, and there's a previous paragraph, merge with the previous paragraph.
             else if (parent instanceof ParagraphNode) {
-                const firstCaret = next ? parent.getLastCaret() : parent.getFirstCaret();
+                const firstCaret = next
+                    ? parent.getLastCaret()
+                    : parent.getFirstCaret();
                 if (firstCaret === undefined)
                     return;
                 const blocks = parents[parents.length - 1];
-                const adjacentBlock = next ? blocks.getBlockAfter(parent) : blocks.getBlockBefore(parent);
+                const adjacentBlock = next
+                    ? blocks.getBlockAfter(parent)
+                    : blocks.getBlockBefore(parent);
                 // Is this the first/last caret of the paragraph and there's an adjascent block? Try deleting something.
-                if (firstCaret.node === caret.node && firstCaret.index === caret.index && adjacentBlock !== undefined) {
+                if (firstCaret.node === caret.node &&
+                    firstCaret.index === caret.index &&
+                    adjacentBlock !== undefined) {
                     // If the block adjacent this paragraph is a paragraph, merge the paragraph into the adjacent paragraph.
                     if (adjacentBlock instanceof ParagraphNode) {
-                        const currentCaret = next ? parent.getLastCaret() : adjacentBlock.getLastCaret();
+                        const currentCaret = next
+                            ? parent.getLastCaret()
+                            : adjacentBlock.getLastCaret();
                         if (currentCaret === undefined)
                             return;
-                        const textIndex = next ? caretToIndex(parent.getFormat(), currentCaret) : caretToIndex(adjacentBlock.getFormat(), currentCaret);
+                        const textIndex = next
+                            ? caretToIndex(parent.getFormat(), currentCaret)
+                            : caretToIndex(adjacentBlock.getFormat(), currentCaret);
                         if (textIndex === undefined)
                             return;
-                        const mergedParagraph = next ? adjacentBlock.withParagraphPrepended(parent) : adjacentBlock.withParagraphAppended(parent);
+                        const mergedParagraph = next
+                            ? adjacentBlock.withParagraphPrepended(parent)
+                            : adjacentBlock.withParagraphAppended(parent);
                         if (mergedParagraph === undefined)
                             return;
-                        const newBlocks = this.withNodeReplaced(blocks, blocks.withChildReplaced(adjacentBlock, mergedParagraph)?.withoutBlock(parent));
+                        const newBlocks = this.withNodeReplaced(blocks, blocks
+                            .withChildReplaced(adjacentBlock, mergedParagraph)
+                            ?.withoutBlock(parent));
                         if (newBlocks === undefined)
                             return;
                         const newCaret = indexToCaret(mergedParagraph.getFormat(), textIndex);
                         if (newCaret === undefined)
                             return;
-                        return { root: newBlocks, range: { start: newCaret, end: newCaret } };
+                        return {
+                            root: newBlocks,
+                            range: { start: newCaret, end: newCaret },
+                        };
                     }
                     // If the block adjacent is a list node, merge the paragraph to the list's first/last item.
                     else if (adjacentBlock instanceof ListNode) {
@@ -610,11 +777,18 @@ export default class BlocksNode extends BlockNode {
                         if (next) {
                             const format = adjacentBlock.getFirstItem();
                             if (format !== undefined) {
-                                const newParagraph = parent.withContent(parent.getFormat().withSegmentsAppended(format));
-                                const newBlocks = blocks.withNodeReplaced(parent, newParagraph)?.withNodeReplaced(format, undefined);
+                                const newParagraph = parent.withContent(parent
+                                    .getFormat()
+                                    .withSegmentsAppended(format));
+                                const newBlocks = blocks
+                                    .withNodeReplaced(parent, newParagraph)
+                                    ?.withNodeReplaced(format, undefined);
                                 if (newBlocks === undefined)
                                     return;
-                                return { root: newBlocks, range: { start: caret, end: caret } };
+                                return {
+                                    root: newBlocks,
+                                    range: { start: caret, end: caret },
+                                };
                             }
                         }
                         // If we're going backwards, get the last format of the list and insert the paragraph's content into it,
@@ -623,18 +797,31 @@ export default class BlocksNode extends BlockNode {
                             const format = adjacentBlock.getLastItem();
                             if (format !== undefined) {
                                 const newFormat = format.withSegmentAppended(parent.getFormat());
-                                const newBlocks = blocks.withNodeReplaced(format, newFormat)?.withoutBlock(parent);
-                                const newCaret = parent.getFormat().getFirstCaret();
-                                if (newBlocks === undefined || newCaret === undefined)
+                                const newBlocks = blocks
+                                    .withNodeReplaced(format, newFormat)
+                                    ?.withoutBlock(parent);
+                                const newCaret = parent
+                                    .getFormat()
+                                    .getFirstCaret();
+                                if (newBlocks === undefined ||
+                                    newCaret === undefined)
                                     return;
-                                return { root: newBlocks, range: { start: newCaret, end: newCaret } };
+                                return {
+                                    root: newBlocks,
+                                    range: { start: newCaret, end: newCaret },
+                                };
                             }
                         }
                     }
                     // Otherwise, return a root without the previous block, deleting it.
                     else {
                         const newBlocks = this.withNodeReplaced(blocks, blocks.withoutBlock(adjacentBlock));
-                        return newBlocks === undefined ? undefined : { root: newBlocks, range: { start: caret, end: caret } };
+                        return newBlocks === undefined
+                            ? undefined
+                            : {
+                                root: newBlocks,
+                                range: { start: caret, end: caret },
+                            };
                     }
                 }
             }
@@ -646,12 +833,16 @@ export default class BlocksNode extends BlockNode {
         if (!this.contains(caret.node))
             return;
         // Get the blocks to insert.
-        const blocks = node instanceof BlocksNode ? node.getBlocks() : node instanceof BlockNode ? [node] : [];
+        const blocks = node instanceof BlocksNode
+            ? node.getBlocks()
+            : node instanceof BlockNode
+                ? [node]
+                : [];
         // If there are none, do nothing.
         if (blocks.length === 0)
             return;
         // Find the block in this blocks node that contains the caret.
-        const anchor = this.#blocks.find(b => b.contains(caret.node));
+        const anchor = this.#blocks.find((b) => b.contains(caret.node));
         if (anchor === undefined)
             return;
         let lastInsert = anchor;
@@ -662,14 +853,18 @@ export default class BlocksNode extends BlockNode {
             if (newBlock === undefined)
                 return;
             // If we're inserting after the anchor and the anchor is a paragraph and the block to insert is a paragraph, merge them.
-            if (lastInsert === anchor && anchor instanceof ParagraphNode && newBlock instanceof ParagraphNode) {
+            if (lastInsert === anchor &&
+                anchor instanceof ParagraphNode &&
+                newBlock instanceof ParagraphNode) {
                 newBlock = anchor.withParagraphAppended(newBlock);
                 if (newBlock === undefined)
                     return;
                 newBlocks = newBlocks.withChildReplaced(anchor, newBlock);
             }
             // If we're inserting after the anchor and the anchor is a list and the block to insert is a list, merge them.
-            else if (lastInsert === anchor && anchor instanceof ListNode && newBlock instanceof ListNode) {
+            else if (lastInsert === anchor &&
+                anchor instanceof ListNode &&
+                newBlock instanceof ListNode) {
                 const edit = anchor.withNodeInserted(caret, newBlock);
                 if (edit === undefined || !(edit.root instanceof BlockNode))
                     return;
@@ -690,7 +885,7 @@ export default class BlocksNode extends BlockNode {
         const formats = lastInsert.getFormats();
         let newCaret = undefined;
         if (formats.length === 0) {
-            const newParagraph = new ParagraphNode(0, new FormatNode("", [new TextNode()]));
+            const newParagraph = new ParagraphNode(0, new FormatNode('', [new TextNode()]));
             newCaret = newParagraph.getFirstCaret();
             newBlocks = newBlocks.withBlockInsertedAfter(lastInsert, newParagraph);
             if (newCaret === undefined || newBlocks === undefined)
@@ -704,6 +899,6 @@ export default class BlocksNode extends BlockNode {
         return { root: newBlocks, range: { start: newCaret, end: newCaret } };
     }
     toHTML() {
-        return this.#blocks.map(b => b.toHTML()).join("");
+        return this.#blocks.map((b) => b.toHTML()).join('');
     }
 }