bookish-press 0.4.1 → 0.4.3

package/models/chapter/FormatNode.test.js

@@ -1,54 +1,96 @@
 import { test, expect } from 'vitest';
-import FormatNode from "./FormatNode";
-import TextNode from "./TextNode";
-test("Bold first two characters", () => {
-    const text = new TextNode("Hello");
-    const format = new FormatNode("", [text]);
-    expect(format.withFormat({ start: { node: text, index: 0 }, end: { node: text, index: 2 } }, "*")?.toBookdown()).toBe("*He*llo");
+import FormatNode from './FormatNode';
+import TextNode from './TextNode';
+test('Bold first two characters', () => {
+    const text = new TextNode('Hello');
+    const format = new FormatNode('', [text]);
+    expect(format
+        .withFormat({
+        start: { node: text, index: 0 },
+        end: { node: text, index: 2 },
+    }, '*')
+        ?.toBookdown()).toBe('*He*llo');
 });
-test("Unbold word", () => {
-    const text = new TextNode("Hello");
-    const format = new FormatNode("", [new FormatNode("*", [text])]);
-    expect(format.withFormat({ start: { node: text, index: 0 }, end: { node: text, index: 5 } }, "")?.toBookdown()).toBe("Hello");
+test('Unbold word', () => {
+    const text = new TextNode('Hello');
+    const format = new FormatNode('', [new FormatNode('*', [text])]);
+    expect(format
+        .withFormat({
+        start: { node: text, index: 0 },
+        end: { node: text, index: 5 },
+    }, '')
+        ?.toBookdown()).toBe('Hello');
 });
-test("Bold single caret position", () => {
-    const text = new TextNode("Hello");
-    const format = new FormatNode("", [text]);
-    expect(format.withFormat({ start: { node: text, index: 2 }, end: { node: text, index: 2 } }, "*")?.toBookdown()).toBe("He**llo");
+test('Bold single caret position', () => {
+    const text = new TextNode('Hello');
+    const format = new FormatNode('', [text]);
+    expect(format
+        .withFormat({
+        start: { node: text, index: 2 },
+        end: { node: text, index: 2 },
+    }, '*')
+        ?.toBookdown()).toBe('He**llo');
 });
-test("Delete first two characters", () => {
-    const text = new TextNode("Hello");
-    const format = new FormatNode("", [text]);
-    expect(format.withoutRange({ start: { node: text, index: 0 }, end: { node: text, index: 2 } })?.toBookdown()).toBe("llo");
+test('Delete first two characters', () => {
+    const text = new TextNode('Hello');
+    const format = new FormatNode('', [text]);
+    expect(format
+        .withoutRange({
+        start: { node: text, index: 0 },
+        end: { node: text, index: 2 },
+    })
+        ?.toBookdown()).toBe('llo');
 });
-test("Delete characters crossing format boundary", () => {
-    const text = new TextNode("He");
-    const bolded = new TextNode("ll");
-    const format = new FormatNode("", [text, new FormatNode("*", [bolded]), new TextNode("o")]);
-    expect(format.withoutRange({ start: { node: text, index: 1 }, end: { node: bolded, index: 1 } })?.toBookdown()).toBe("H*l*o");
+test('Delete characters crossing format boundary', () => {
+    const text = new TextNode('He');
+    const bolded = new TextNode('ll');
+    const format = new FormatNode('', [
+        text,
+        new FormatNode('*', [bolded]),
+        new TextNode('o'),
+    ]);
+    expect(format
+        .withoutRange({
+        start: { node: text, index: 1 },
+        end: { node: bolded, index: 1 },
+    })
+        ?.toBookdown()).toBe('H*l*o');
 });
-test("Split", () => {
-    const text = new TextNode("This is my paragraph. It is two sentences.");
-    const indexAfterPeriod = text.getText().indexOf(".") + 1;
+test('Split', () => {
+    const text = new TextNode('This is my paragraph. It is two sentences.');
+    const indexAfterPeriod = text.getText().indexOf('.') + 1;
     const caret = { node: text, index: indexAfterPeriod };
-    const format = new FormatNode("", [text]);
-    expect(format.split(caret)?.map(t => t.toBookdown()).join("THEN")).toBe("This is my paragraph.THEN It is two sentences.");
+    const format = new FormatNode('', [text]);
+    expect(format
+        .split(caret)
+        ?.map((t) => t.toBookdown())
+        .join('THEN')).toBe('This is my paragraph.THEN It is two sentences.');
 });
-test("Backspace/delete", () => {
-    const first = new TextNode("Hello, my name is ");
-    const second = new TextNode("Amy");
-    const third = new TextNode(".");
-    const format = new FormatNode("", [first, new FormatNode("*", [second]), third]);
-    expect(format.withoutCharacter({ node: first, index: 5 }, false)?.root.toBookdown())
-        .toBe("Hell, my name is *Amy*.");
-    expect(format.withoutCharacter({ node: first, index: 5 }, true)?.root.toBookdown())
-        .toBe("Hello my name is *Amy*.");
-    expect(format.withoutCharacter({ node: second, index: 0 }, false)?.root.toBookdown())
-        .toBe("Hello, my name is*Amy*.");
-    expect(format.withoutCharacter({ node: second, index: 0 }, true)?.root.toBookdown())
-        .toBe("Hello, my name is *my*.");
-    expect(format.withoutCharacter({ node: first, index: 0 }, false)?.root.toBookdown())
-        .toBeUndefined();
-    expect(format.withoutCharacter({ node: third, index: 1 }, true)?.root.toBookdown())
-        .toBeUndefined();
+test('Backspace/delete', () => {
+    const first = new TextNode('Hello, my name is ');
+    const second = new TextNode('Amy');
+    const third = new TextNode('.');
+    const format = new FormatNode('', [
+        first,
+        new FormatNode('*', [second]),
+        third,
+    ]);
+    expect(format
+        .withoutCharacter({ node: first, index: 5 }, false)
+        ?.root.toBookdown()).toBe('Hell, my name is *Amy*.');
+    expect(format
+        .withoutCharacter({ node: first, index: 5 }, true)
+        ?.root.toBookdown()).toBe('Hello my name is *Amy*.');
+    expect(format
+        .withoutCharacter({ node: second, index: 0 }, false)
+        ?.root.toBookdown()).toBe('Hello, my name is*Amy*.');
+    expect(format
+        .withoutCharacter({ node: second, index: 0 }, true)
+        ?.root.toBookdown()).toBe('Hello, my name is *my*.');
+    expect(format
+        .withoutCharacter({ node: first, index: 0 }, false)
+        ?.root.toBookdown()).toBeUndefined();
+    expect(format
+        .withoutCharacter({ node: third, index: 1 }, true)
+        ?.root.toBookdown()).toBeUndefined();
 });

package/models/chapter/InlineCodeNode.d.ts

@@ -1,5 +1,5 @@
-import MetadataNode from "./MetadataNode";
-import TextNode from "./TextNode";
+import MetadataNode from './MetadataNode';
+import TextNode from './TextNode';
 export default class InlineCodeNode extends MetadataNode<string> {
     constructor(code?: TextNode, language?: string);
     getType(): string;

package/models/chapter/InlineCodeNode.js

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

package/models/chapter/LabelNode.d.ts

@@ -1,7 +1,7 @@
-import AtomNode from "./AtomNode";
-import type Caret from "./Caret";
-import type FormatNode from "./FormatNode";
-import type Node from "./Node";
+import AtomNode from './AtomNode';
+import type Caret from './Caret';
+import type FormatNode from './FormatNode';
+import type Node from './Node';
 export default class LabelNode extends AtomNode<string> {
     constructor(newID: string);
     getType(): string;

package/models/chapter/LabelNode.js

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

package/models/chapter/LinkNode.d.ts

@@ -1,5 +1,5 @@
-import MetadataNode from "./MetadataNode";
-import TextNode from "./TextNode";
+import MetadataNode from './MetadataNode';
+import TextNode from './TextNode';
 export default class LinkNode extends MetadataNode<string> {
     constructor(text?: TextNode, url?: string);
     getType(): string;

package/models/chapter/LinkNode.js

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

package/models/chapter/ListNode.d.ts

@@ -1,11 +1,11 @@
-import type Node from "./Node";
-import FormatNode from "./FormatNode";
-import type { Format } from "./FormatNode";
-import type Caret from "./Caret";
-import { type CaretRange } from "./Caret";
-import BlockNode from "./BlockNode";
-import type Edit from "./Edit";
-export declare type ListNodeType = FormatNode | ListNode;
+import type Node from './Node';
+import FormatNode from './FormatNode';
+import type { Format } from './FormatNode';
+import type Caret from './Caret';
+import { type CaretRange } from './Caret';
+import BlockNode from './BlockNode';
+import type Edit from './Edit';
+export type ListNodeType = FormatNode | ListNode;
 export default class ListNode extends BlockNode {
     #private;
     constructor(items: Array<FormatNode | ListNode>, numbered: boolean);

package/models/chapter/ListNode.js

@@ -1,6 +1,6 @@
-import FormatNode from "./FormatNode";
-import { caretToIndex, indexToCaret } from "./Caret";
-import BlockNode from "./BlockNode";
+import FormatNode from './FormatNode';
+import { caretToIndex, indexToCaret } from './Caret';
+import BlockNode from './BlockNode';
 export default class ListNode extends BlockNode {
     #numbered;
     #items;
@@ -9,22 +9,43 @@ export default class ListNode extends BlockNode {
         this.#numbered = numbered;
         let adjustedItems = items
             // Make sure all format nodes have an empty text.
-            .map(i => i instanceof FormatNode ? i.withTextIfEmpty() : i)
+            .map((i) => (i instanceof FormatNode ? i.withTextIfEmpty() : i))
             // Strip all empty sublists.
-            .filter(i => !i.isEmpty());
+            .filter((i) => !i.isEmpty());
         this.#items = adjustedItems;
     }
-    getType() { return "list"; }
-    isNumbered() { return this.#numbered; }
-    isEmpty() { return this.#items.length === 0 || this.#items.every(i => i instanceof ListNode && i.isEmpty()); }
-    getItems() { return this.#items; }
-    getChildren() { return this.#items; }
-    getListItems() { return this.#items.filter(i => i instanceof ListNode); }
-    getLength() { return this.#items.length; }
-    getLastItem() { return this.getFirstLastItem(false); }
-    getFirstItem() { return this.getFirstLastItem(true); }
+    getType() {
+        return 'list';
+    }
+    isNumbered() {
+        return this.#numbered;
+    }
+    isEmpty() {
+        return (this.#items.length === 0 ||
+            this.#items.every((i) => i instanceof ListNode && i.isEmpty()));
+    }
+    getItems() {
+        return this.#items;
+    }
+    getChildren() {
+        return this.#items;
+    }
+    getListItems() {
+        return this.#items.filter((i) => i instanceof ListNode);
+    }
+    getLength() {
+        return this.#items.length;
+    }
+    getLastItem() {
+        return this.getFirstLastItem(false);
+    }
+    getFirstItem() {
+        return this.getFirstLastItem(true);
+    }
     getFormats() {
-        return this.#items.reduce((previous, current) => previous.concat(current instanceof FormatNode ? [current] : current.getFormats()), []);
+        return this.#items.reduce((previous, current) => previous.concat(current instanceof FormatNode
+            ? [current]
+            : current.getFormats()), []);
     }
     getFirstLastItem(first) {
         if (this.#items.length === 0)
@@ -44,30 +65,46 @@ export default class ListNode extends BlockNode {
             return 1;
     }
     toText() {
-        return this.#items.map(item => item.toText()).join(" ");
+        return this.#items.map((item) => item.toText()).join(' ');
     }
     toBookdown(level = 1) {
-        return this.isNumbered() ?
-            this.#items.map((item, number) => (item instanceof ListNode ? "" : ((number + 1) + ".".repeat(level)) + " ") + item.toBookdown(level + 1)).join("\n") :
-            this.#items.map(item => (item instanceof ListNode ? "" : "*".repeat(level) + " ") + item.toBookdown(level + 1)).join("\n");
+        return this.isNumbered()
+            ? this.#items
+                .map((item, number) => (item instanceof ListNode
+                ? ''
+                : number + 1 + '.'.repeat(level) + ' ') +
+                item.toBookdown(level + 1))
+                .join('\n')
+            : this.#items
+                .map((item) => (item instanceof ListNode
+                ? ''
+                : '*'.repeat(level) + ' ') +
+                item.toBookdown(level + 1))
+                .join('\n');
     }
     toHTML() {
-        return this.isNumbered() ?
-            `<ol>${this.#items.map(i => `<li>${i.toHTML()}</li>`).join("")}</ol>` :
-            `<ul>${this.#items.map(i => `<li>${i.toHTML()}</li>`).join("")}</ul>`;
+        return this.isNumbered()
+            ? `<ol>${this.#items
+                .map((i) => `<li>${i.toHTML()}</li>`)
+                .join('')}</ol>`
+            : `<ul>${this.#items
+                .map((i) => `<li>${i.toHTML()}</li>`)
+                .join('')}</ul>`;
     }
     getParentOf(node) {
-        return this.#items.map(b => b === node ? this : b.getParentOf(node)).find(b => b !== undefined);
+        return this.#items
+            .map((b) => (b === node ? this : b.getParentOf(node)))
+            .find((b) => b !== undefined);
     }
     atBeginningOfItem(root, caret) {
-        const format = caret.node.getFarthestParentMatching(root, n => n instanceof FormatNode);
-        return format !== undefined &&
+        const format = caret.node.getFarthestParentMatching(root, (n) => n instanceof FormatNode);
+        return (format !== undefined &&
             caret.node.hasAncestor(root, this) &&
             caret.index === 0 &&
-            format.getTextNodes()[0] === caret.node;
+            format.getTextNodes()[0] === caret.node);
     }
     getItemContaining(caret) {
-        const match = this.#items.find(n => n.getParentOf(caret.node) !== undefined);
+        const match = this.#items.find((n) => n.getParentOf(caret.node) !== undefined);
         if (match === undefined)
             return undefined;
         const index = this.#items.indexOf(match);
@@ -80,9 +117,13 @@ export default class ListNode extends BlockNode {
             return;
         return this.#items[index];
     }
-    getFirstCaret() { return this.#items.length === 0 ? undefined : this.#items[0].getFirstCaret(); }
+    getFirstCaret() {
+        return this.#items.length === 0
+            ? undefined
+            : this.#items[0].getFirstCaret();
+    }
     copy() {
-        return new ListNode(this.#items.map(i => i.copy()), this.#numbered);
+        return new ListNode(this.#items.map((i) => i.copy()), this.#numbered);
     }
     withStyle(numbered) {
         return new ListNode(this.#items, numbered);
@@ -211,14 +252,16 @@ export default class ListNode extends BlockNode {
     }
     withItemSplit(caret) {
         // Which item contains the caret?
-        const item = this.#items.find(i => i instanceof FormatNode && i.contains(caret.node));
+        const item = this.#items.find((i) => i instanceof FormatNode && i.contains(caret.node));
         if (item === undefined)
             return;
         const parts = item.split(caret);
         if (parts === undefined)
             return;
         const [first, second] = parts;
-        return this.withItemAfter(second, item)?.withItemAfter(first, item)?.withoutItem(item);
+        return this.withItemAfter(second, item)
+            ?.withItemAfter(first, item)
+            ?.withoutItem(item);
     }
     // Recursively search for the given item and indent it, constructing a new list.
     withItemIndented(format) {
@@ -283,9 +326,16 @@ export default class ListNode extends BlockNode {
         const index = this.#items.indexOf(node);
         if (index < 0)
             return;
-        return new ListNode(replacement === undefined ?
-            [...this.#items.slice(0, index), ...this.#items.slice(index + 1)] :
-            [...this.#items.slice(0, index), replacement, ...this.#items.slice(index + 1)], this.#numbered);
+        return new ListNode(replacement === undefined
+            ? [
+                ...this.#items.slice(0, index),
+                ...this.#items.slice(index + 1),
+            ]
+            : [
+                ...this.#items.slice(0, index),
+                replacement,
+                ...this.#items.slice(index + 1),
+            ], this.#numbered);
     }
     withContentInRange(range) {
         const containsStart = this.contains(range.start.node);
@@ -316,7 +366,7 @@ export default class ListNode extends BlockNode {
         if (!(node instanceof ListNode))
             return;
         // Find the anchor item.
-        const anchor = this.#items.find(i => i.contains(caret.node));
+        const anchor = this.#items.find((i) => i.contains(caret.node));
         if (anchor === undefined)
             return;
         const items = node.getItems();
@@ -343,7 +393,9 @@ export default class ListNode extends BlockNode {
             lastItem = item;
         }
         // The caret should be the last item inserted.
-        const newCaret = lastItem instanceof FormatNode ? lastItem.getLastCaret() : lastItem.getLastItem()?.getLastCaret();
+        const newCaret = lastItem instanceof FormatNode
+            ? lastItem.getLastCaret()
+            : lastItem.getLastItem()?.getLastCaret();
         if (newCaret === undefined)
             return;
         return { root: newList, range: { start: newCaret, end: newCaret } };
@@ -352,9 +404,15 @@ export default class ListNode extends BlockNode {
         const sortedRange = this.sortRange(range);
         const itemStart = this.getItemContaining(sortedRange.start);
         const itemEnd = this.getItemContaining(sortedRange.end);
+        // This edits all of the formats contained in the range in the list, since the BlockNode class doesn't care about
+        // what formats are stored in.
         const edit = super.withRangeFormatted(sortedRange, format);
         // If we were deleting and two list items were involved, merge them.
-        if (edit && format === undefined && itemStart !== undefined && itemEnd !== undefined && itemStart !== itemEnd) {
+        if (edit &&
+            format === undefined &&
+            itemStart !== undefined &&
+            itemEnd !== undefined &&
+            itemStart !== itemEnd) {
             const newList = edit.root;
             const itemIndex = itemEnd - (this.#items.length - newList.#items.length);
             if (itemIndex > 0 && newList.getLength() > 1) {
@@ -362,7 +420,10 @@ export default class ListNode extends BlockNode {
                 const mergedEdit = newList.withItemMergedBackwards(itemIndex);
                 if (mergedEdit === undefined)
                     return;
-                return { root: mergedEdit[0], range: { start: mergedEdit[1], end: mergedEdit[1] } };
+                return {
+                    root: mergedEdit[0],
+                    range: { start: mergedEdit[1], end: mergedEdit[1] },
+                };
             }
         }
         return edit;

package/models/chapter/ListNode.test.js

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

package/models/chapter/MetadataNode.d.ts

@@ -1,6 +1,6 @@
-import type { CaretRange } from "./Caret";
-import Node from "./Node";
-import type TextNode from "./TextNode";
+import type { CaretRange } from './Caret';
+import Node from './Node';
+import type TextNode from './TextNode';
 export default abstract class MetadataNode<MetaType> extends Node {
     #private;
     constructor(text: TextNode, meta: MetaType);