react-headless-mde 2.0.3 → 3.0.0-beta1

package/dist/esm/index.js

@@ -1,24 +1,4 @@
-import { useRef, useMemo } from 'react';
-
-class CommandController {
-    constructor(textController, commandMap) {
-        this.textController = textController;
-        this.commandMap = commandMap;
-    }
-    executeCommand(commandName) {
-        var _a;
-        const command = this.commandMap[commandName];
-        if (!command) {
-            throw new Error(`Cannot execute command. Command not found: ${commandName}`);
-        }
-        if (command.undo && ((_a = command.shouldUndo) === null || _a === void 0 ? void 0 : _a.call(command, this.textController))) {
-            command.undo(this.textController);
-        }
-        else {
-            command.do(this.textController);
-        }
-    }
-}
+import { useRef, useEffect, useMemo } from 'react';
 
 /**
  * Inserts the given text at the cursor. If the element contains a selection, the selection
@@ -118,8 +98,6 @@ function canManipulateViaTextNodes(input) {
     return browserSupportsTextareaTextNodes;
 }
 
-// A list of helpers for manipulating Markdown text.
-// These helpers do not interface with a textarea.
 // Check if char is "space" or "new line".
 // Char is optional because we pass a char by index,
 // and theoretically index can be outside the string range. See text[i - 1] and text[i].
@@ -168,6 +146,16 @@ function selectAfterWord({ text, selection }) {
     }
     return selection;
 }
+// Expands the selection to cover the whole lines it touches:
+// the start moves to the beginning of the first line, the end — to the end of the last one
+function getLineSelection({ text, selection }) {
+    let { start, end } = selection;
+    while (start > 0 && text[start - 1] !== '\n')
+        start--;
+    while (end < text.length && text[end] !== '\n')
+        end++;
+    return { start, end };
+}
 // Gets the number of line-breaks that would have to be inserted before the given 'startPosition'
 // to make sure there's an empty line between 'startPosition' and the previous text
 function getBreaksNeededForEmptyLineBefore(text = '', startPosition) {
@@ -191,7 +179,7 @@ function getBreaksNeededForEmptyLineBefore(text = '', startPosition) {
                 return neededBreaks;
         }
     }
-    return isInFirstLine ? 0 : neededBreaks;
+    return isInFirstLine ? 0 : Math.max(0, neededBreaks);
 }
 // Gets the number of line-breaks that would have to be inserted after the given 'startPosition'
 // to make sure there's an empty line between 'startPosition' and the next text
@@ -217,7 +205,7 @@ function getBreaksNeededForEmptyLineAfter(text = '', startPosition) {
                 return neededBreaks;
         }
     }
-    return isInLastLine ? 0 : neededBreaks;
+    return isInLastLine ? 0 : Math.max(0, neededBreaks);
 }
 function getSelectedText(textSection) {
     return textSection.text.slice(textSection.selection.start, textSection.selection.end);
@@ -251,14 +239,15 @@ function insertBeforeEachLine(selectedText, insertBefore) {
 
 var selectionAndText = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getWordSelection: getWordSelection,
-    selectAfterWord: selectAfterWord,
-    getBreaksNeededForEmptyLineBefore: getBreaksNeededForEmptyLineBefore,
     getBreaksNeededForEmptyLineAfter: getBreaksNeededForEmptyLineAfter,
+    getBreaksNeededForEmptyLineBefore: getBreaksNeededForEmptyLineBefore,
+    getLineSelection: getLineSelection,
     getSelectedText: getSelectedText,
-    getStringBeforeSelection: getStringBeforeSelection,
     getStringAfterSelection: getStringAfterSelection,
-    insertBeforeEachLine: insertBeforeEachLine
+    getStringBeforeSelection: getStringBeforeSelection,
+    getWordSelection: getWordSelection,
+    insertBeforeEachLine: insertBeforeEachLine,
+    selectAfterWord: selectAfterWord
 });
 
 function getStateFromTextArea(textArea) {
@@ -316,9 +305,9 @@ class TextareaController {
         const state1 = this.getState();
         // Replaces the current selection with new string
         const state2 = this.replaceSelection(`${prefix}${getSelectedText(state1)}${suffix}`);
-        // Adjust the selection to not contain the **
+        // Adjust the selection to not contain the prefix and suffix
         return this.setSelection({
-            start: state2.selection.end - prefix.length - getSelectedText(state1).length,
+            start: state2.selection.end - suffix.length - getSelectedText(state1).length,
             end: state2.selection.end - suffix.length,
         });
     }
@@ -349,262 +338,349 @@ class TextareaController {
 
 function useTextAreaMarkdownEditor(options) {
     const textAreaRef = useRef(null);
+    // Always execute commands from the most recent render
+    const commandMapRef = useRef(options.commandMap);
+    useEffect(() => {
+        commandMapRef.current = options.commandMap;
+    });
+    // Command instances persist between executor rebuilds
+    const instancesRef = useRef(new Map());
+    // Rebuild the executors object only when the set of command names changes,
+    // so `commands` (and each executor) stays referentially stable between renders
+    const commandNames = Object.keys(options.commandMap).sort().join('\0');
     return useMemo(() => {
         const textController = new TextareaController(textAreaRef);
-        const commandController = new CommandController(textController, options.commandMap);
+        const instances = instancesRef.current;
+        const executors = {};
+        for (const name of commandNames.split('\0')) {
+            if (name === '')
+                continue;
+            executors[name] = (context) => {
+                var _a;
+                const CommandClass = commandMapRef.current[name];
+                if (CommandClass === undefined) {
+                    throw new Error(`Cannot execute command. Command not found: ${name}`);
+                }
+                let instance = instances.get(name);
+                if (instance === undefined || instance.constructor !== CommandClass) {
+                    instance = new CommandClass(textController);
+                    instances.set(name, instance);
+                }
+                if (instance.undo !== undefined && ((_a = instance.shouldUndo) === null || _a === void 0 ? void 0 : _a.call(instance, context)) === true) {
+                    instance.undo(context);
+                }
+                else {
+                    instance.do(context);
+                }
+            };
+        }
         return {
             ref: textAreaRef,
             textController,
-            commandController,
+            commands: executors,
         };
-    }, [textAreaRef]);
+    }, [commandNames]);
 }
 
-function makeList(state0, textController, insertBefore) {
-    // Adjust the selection to encompass the whole word if the caret is inside one
-    const newSelectionRange = getWordSelection({
-        text: state0.text,
-        selection: state0.selection,
-    });
-    const state1 = textController.setSelection(newSelectionRange);
-    const breaksBeforeCount = getBreaksNeededForEmptyLineBefore(state1.text, state1.selection.start);
-    const breaksBefore = Array(breaksBeforeCount + 1).join('\n');
-    const breaksAfterCount = getBreaksNeededForEmptyLineAfter(state1.text, state1.selection.end);
-    const breaksAfter = Array(breaksAfterCount + 1).join('\n');
-    const modifiedText = insertBeforeEachLine(getSelectedText(state1), insertBefore);
-    textController.replaceSelection(`${breaksBefore}${modifiedText.modifiedText}${breaksAfter}`);
-    // Specifically when the text has only one line, we can exclude the "- ", for example, from the selection
-    const oneLinerOffset = !getSelectedText(state1).includes('\n') ? modifiedText.insertionLength : 0;
-    const selectionStart = state1.selection.start + breaksBeforeCount + oneLinerOffset;
-    const selectionEnd = selectionStart + modifiedText.modifiedText.length - oneLinerOffset;
-    // Adjust the selection to not contain the **
-    textController.setSelection({
-        start: selectionStart,
-        end: selectionEnd,
-    });
+/**
+ * Base class for all commands.
+ *
+ * `Context` is the type of the value that must be passed when the command is executed.
+ * Commands without a context extend `BaseCommand` (Context = void) and are executed
+ * without arguments; commands with a context extend `BaseCommand<Context>` and require
+ * an argument of that type:
+ *
+ * class AttachmentCommand extends BaseCommand<Promise<string>> {
+ *   async do(upload: Promise<string>) {
+ *     const url = await upload;
+ *     this.textController.replaceSelection(`![](${url})`);
+ *   }
+ * }
+ */
+class BaseCommand {
+    constructor(textController) {
+        this.textController = textController;
+    }
 }
 
-var list = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    makeList: makeList
-});
-
-function setHeader(initialState, api, prefix) {
-    // Adjust the selection to encompass the whole word if the caret is inside one
-    const newSelectionRange = getWordSelection({
-        text: initialState.text,
-        selection: initialState.selection,
-    });
-    const state1 = api.setSelection(newSelectionRange);
-    // Add the prefix to the selection
-    const state2 = api.replaceSelection(`${prefix}${getSelectedText(state1)}`);
-    // Adjust the selection to not contain the prefix
-    api.setSelection({
-        start: state2.selection.end - getSelectedText(state1).length,
-        end: state2.selection.end,
-    });
+// Base class for commands that wrap a word/selection with prefix and suffix: bold, italic etc.
+class WrapCommand extends BaseCommand {
+    do() {
+        // Adjust the selection to encompass the whole word if the caret is inside one
+        this.textController.selectWordByCursor();
+        this.textController.wrapSelection(this.prefix, this.suffix);
+    }
+    shouldUndo() {
+        const state = this.getWordSelectionState();
+        return this.hasMarkersInside(getSelectedText(state)) || this.hasMarkersOutside(state);
+    }
+    undo() {
+        const state = this.getWordSelectionState();
+        const selectedText = getSelectedText(state);
+        this.textController.setSelection(state.selection);
+        if (!this.hasMarkersInside(selectedText)) {
+            // The markers surround the selection: `**[word]**`
+            this.textController.unwrapSelection(this.prefix.length, this.suffix.length);
+            return;
+        }
+        // The markers are inside the selection — the caret is within `**wo|rd**`:
+        // strip the markers from the edges of the selection
+        const innerText = selectedText.slice(this.prefix.length, selectedText.length - this.suffix.length);
+        const replacedState = this.textController.replaceSelection(innerText);
+        this.textController.setSelection({
+            start: replacedState.selection.end - innerText.length,
+            end: replacedState.selection.end,
+        });
+    }
+    getWordSelectionState() {
+        const state = this.textController.getState();
+        return {
+            text: state.text,
+            selection: getWordSelection(state),
+        };
+    }
+    hasMarkersInside(selectedText) {
+        return (selectedText.length >= this.prefix.length + this.suffix.length &&
+            selectedText.startsWith(this.prefix) &&
+            selectedText.endsWith(this.suffix));
+    }
+    hasMarkersOutside({ text, selection }) {
+        const markersMatch = getStringBeforeSelection({ text, selection }, this.prefix.length) === this.prefix &&
+            getStringAfterSelection({ text, selection }, this.suffix.length) === this.suffix;
+        if (!markersMatch)
+            return false;
+        // The characters right next to the markers must not continue the marker sequence:
+        // `*` around `[word]` inside `**word**` is bold, not italic
+        const charBeforeMarkers = text[selection.start - this.prefix.length - 1];
+        const charAfterMarkers = text[selection.end + this.suffix.length];
+        return charBeforeMarkers !== this.prefix[0] && charAfterMarkers !== this.suffix[this.suffix.length - 1];
+    }
 }
 
-var header = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    setHeader: setHeader
-});
-
-const boldCommand = {
-    shouldUndo: textCtrl => {
-        const wordSelectionState = textCtrl.selectWordByCursor();
-        return (getStringBeforeSelection(wordSelectionState, 2) === '**' &&
-            getStringAfterSelection(wordSelectionState, 2) === '**');
-    },
-    do: textCtrl => {
-        textCtrl.wrapSelection('**', '**');
-    },
-    undo: textCtrl => {
-        textCtrl.unwrapSelection(2, 2);
-    },
-};
+// Base class for line-level commands that prefix each selected line: quote, headings.
+// The selection is expanded to cover the whole lines it touches.
+// Executing the command on already prefixed lines removes the prefixes (undo).
+class LinePrefixCommand extends BaseCommand {
+    do() {
+        const state = this.textController.getState();
+        const state1 = this.textController.setSelection(getLineSelection(state));
+        const selectedText = getSelectedText(state1);
+        const { modifiedText } = insertBeforeEachLine(selectedText, this.prefix);
+        const state2 = this.textController.replaceSelection(modifiedText);
+        // For a single line select the content without the prefix,
+        // for multiple lines select the whole modified block
+        const prefixOffset = selectedText.includes('\n') ? 0 : this.prefix.length;
+        this.textController.setSelection({
+            start: state2.selection.end - modifiedText.length + prefixOffset,
+            end: state2.selection.end,
+        });
+    }
+    shouldUndo() {
+        const state = this.textController.getState();
+        const selectedText = getSelectedText({
+            text: state.text,
+            selection: getLineSelection(state),
+        });
+        return selectedText.split('\n').every(line => line.startsWith(this.prefix));
+    }
+    undo() {
+        const state = this.textController.getState();
+        const state1 = this.textController.setSelection(getLineSelection(state));
+        const modifiedText = getSelectedText(state1)
+            .split('\n')
+            .map(line => (line.startsWith(this.prefix) ? line.slice(this.prefix.length) : line))
+            .join('\n');
+        this.textController.replaceSelection(modifiedText);
+        // Select the content of the un-prefixed line(s)
+        this.textController.setSelection({
+            start: state1.selection.start,
+            end: state1.selection.start + modifiedText.length,
+        });
+    }
+}
 
-const italicCommand = {
-    shouldUndo: textCtrl => {
-        const wordSelectionState = textCtrl.selectWordByCursor();
-        return (getStringBeforeSelection(wordSelectionState, 1) === '*' && getStringAfterSelection(wordSelectionState, 1) === '*');
-    },
-    do(textCtrl) {
-        textCtrl.wrapSelection('*', '*');
-    },
-    undo(textCtrl) {
-        textCtrl.unwrapSelection(1, 1);
-    },
-};
+// Base class for list commands. Each selected line becomes a list item.
+// The selection is expanded to cover the whole lines it touches; when a list is
+// inserted in the middle of a paragraph, it is separated by empty lines.
+class ListCommand extends BaseCommand {
+    do() {
+        const state0 = this.textController.getState();
+        const state1 = this.textController.setSelection(getLineSelection(state0));
+        const breaksBeforeCount = getBreaksNeededForEmptyLineBefore(state1.text, state1.selection.start);
+        const breaksBefore = '\n'.repeat(breaksBeforeCount);
+        const breaksAfterCount = getBreaksNeededForEmptyLineAfter(state1.text, state1.selection.end);
+        const breaksAfter = '\n'.repeat(breaksAfterCount);
+        const selectedText = getSelectedText(state1);
+        const { modifiedText } = insertBeforeEachLine(selectedText, (line, index) => this.getLinePrefix(line, index));
+        this.textController.replaceSelection(`${breaksBefore}${modifiedText}${breaksAfter}`);
+        // For a single line select the content without the prefix,
+        // for multiple lines select the whole modified block
+        const prefixOffset = selectedText.includes('\n') ? 0 : this.getLinePrefix('', 0).length;
+        const blockStart = state1.selection.start + breaksBeforeCount;
+        this.textController.setSelection({
+            start: blockStart + prefixOffset,
+            end: blockStart + modifiedText.length,
+        });
+    }
+}
 
-const strikethroughCommand = {
-    shouldUndo(textCtrl) {
-        const wordSelectionState = textCtrl.selectWordByCursor();
-        return (getStringBeforeSelection(wordSelectionState, 2) === '~~' &&
-            getStringAfterSelection(wordSelectionState, 2) === '~~');
-    },
-    do(textCtrl) {
-        textCtrl.wrapSelection('~~', '~~');
-    },
-    undo(textCtrl) {
-        textCtrl.unwrapSelection(2, 2);
-    },
-};
+class BoldCommand extends WrapCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '**';
+        this.suffix = '**';
+    }
+}
 
-const linkCommand = {
-    do: textApi => {
-        // Adjust the selection to encompass the whole word if the caret is inside one
-        const wordSelectionState = textApi.selectWordByCursor();
-        // Replaces the current selection with the bold mark up
-        const state2 = textApi.replaceSelection(`[${getSelectedText(wordSelectionState)}](url)`);
-        // Adjust the selection to not contain the **
-        textApi.setSelection({
-            start: state2.selection.end - 6 - getSelectedText(wordSelectionState).length,
-            end: state2.selection.end - 6,
-        });
-    },
-};
+class ItalicCommand extends WrapCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '*';
+        this.suffix = '*';
+    }
+}
 
-// Todo: try to rewrite with setHeader()
-const quoteCommand = {
-    do: textApi => {
-        // Adjust the selection to encompass the whole word if the caret is inside one
-        const state = textApi.selectWordByCursor();
-        const breaksBeforeCount = getBreaksNeededForEmptyLineBefore(state.text, state.selection.start);
-        const breaksBefore = Array(breaksBeforeCount + 1).join('\n');
-        const breaksAfterCount = getBreaksNeededForEmptyLineAfter(state.text, state.selection.end);
-        const breaksAfter = Array(breaksAfterCount + 1).join('\n');
-        // Replaces the current selection with the quote mark up
-        textApi.replaceSelection(`${breaksBefore}> ${getSelectedText(state)}${breaksAfter}`);
-        const selectionStart = state.selection.start + breaksBeforeCount + 2;
-        const selectionEnd = selectionStart + getSelectedText(state).length;
-        textApi.setSelection({
-            start: selectionStart,
-            end: selectionEnd,
-        });
-    },
-};
+class StrikethroughCommand extends WrapCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '~~';
+        this.suffix = '~~';
+    }
+}
 
-const codeCommand = {
-    shouldUndo: textCtrl => {
-        const wordSelectionState = textCtrl.selectWordByCursor();
-        return (getStringBeforeSelection(wordSelectionState, 1) === '`' && getStringAfterSelection(wordSelectionState, 1) === '`');
-    },
-    do(textCtrl) {
-        textCtrl.wrapSelection('`', '`');
-    },
-    undo(textCtrl) {
-        textCtrl.unwrapSelection(1, 1);
-    },
-};
+class CodeCommand extends WrapCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '`';
+        this.suffix = '`';
+    }
+}
 
-const codeBlockCommand = {
-    do: textApi => {
+class CodeBlockCommand extends BaseCommand {
+    do() {
+        const textApi = this.textController;
         // Adjust the selection to encompass the whole word if the caret is inside one
         const state1 = textApi.selectWordByCursor();
-        // when there's no breaking line
-        if (!getSelectedText(state1).includes('\n')) {
-            textApi.replaceSelection(`\`${getSelectedText(state1)}\``);
-            // Adjust the selection to not contain the **
-            const selectionStart = state1.selection.start + 1;
-            const selectionEnd = selectionStart + getSelectedText(state1).length;
+        const selectedText = getSelectedText(state1);
+        // when there's no breaking line — inline code
+        if (!selectedText.includes('\n')) {
+            textApi.replaceSelection(`\`${selectedText}\``);
             textApi.setSelection({
-                start: selectionStart,
-                end: selectionEnd,
+                start: state1.selection.start + 1,
+                end: state1.selection.start + 1 + selectedText.length,
             });
             return;
         }
         const breaksBeforeCount = getBreaksNeededForEmptyLineBefore(state1.text, state1.selection.start);
-        const breaksBefore = Array(breaksBeforeCount + 1).join('\n');
+        const breaksBefore = '\n'.repeat(breaksBeforeCount);
         const breaksAfterCount = getBreaksNeededForEmptyLineAfter(state1.text, state1.selection.end);
-        const breaksAfter = Array(breaksAfterCount + 1).join('\n');
-        textApi.replaceSelection(`${breaksBefore}\`\`\`\n${getSelectedText(state1)}\n\`\`\`${breaksAfter}`);
+        const breaksAfter = '\n'.repeat(breaksAfterCount);
+        textApi.replaceSelection(`${breaksBefore}\`\`\`\n${selectedText}\n\`\`\`${breaksAfter}`);
         const selectionStart = state1.selection.start + breaksBeforeCount + 4;
-        const selectionEnd = selectionStart + getSelectedText(state1).length;
         textApi.setSelection({
             start: selectionStart,
-            end: selectionEnd,
+            end: selectionStart + selectedText.length,
         });
-    },
-};
-
-const checkedListCommand = {
-    do: textApi => {
-        const initialState = textApi.getState();
-        makeList(initialState, textApi, () => `- [ ] `);
-    },
-};
-
-const orderedListCommand = {
-    do: textApi => {
-        const initialState = textApi.getState();
-        makeList(initialState, textApi, (item, index) => `${index + 1}. `);
-    },
-};
+    }
+}
 
-const unorderedListCommand = {
-    do: textApi => {
-        const initialState = textApi.getState();
-        makeList(initialState, textApi, '- ');
-    },
-};
+class LinkCommand extends BaseCommand {
+    do() {
+        const textApi = this.textController;
+        // Adjust the selection to encompass the whole word if the caret is inside one
+        const wordSelectionState = textApi.selectWordByCursor();
+        // Replaces the current selection with the link markup
+        const state2 = textApi.replaceSelection(`[${getSelectedText(wordSelectionState)}](url)`);
+        // Select the `url` placeholder so it can be replaced right away
+        textApi.setSelection({
+            start: state2.selection.end - 4,
+            end: state2.selection.end - 1,
+        });
+    }
+}
 
-const imageCommand = {
-    do: textApi => {
-        // Replaces the current selection with the whole word selected
+class ImageCommand extends BaseCommand {
+    do() {
+        const textApi = this.textController;
+        // Adjust the selection to encompass the whole word if the caret is inside one
         const wordSelectionState = textApi.selectWordByCursor();
         // Replaces the current selection with the image
         const imageTemplate = getSelectedText(wordSelectionState) || 'https://example.com/your-image.png';
         textApi.replaceSelection(`![](${imageTemplate})`);
-        // Adjust the selection to not contain the **
+        // Select the image url so it can be replaced right away
         textApi.setSelection({
             start: wordSelectionState.selection.start + 4,
             end: wordSelectionState.selection.start + 4 + imageTemplate.length,
         });
-    },
-};
+    }
+}
 
-const headingLevel1Command = {
-    do: textCtrl => {
-        const initialState = textCtrl.getState();
-        setHeader(initialState, textCtrl, '# ');
-    },
-};
+class QuoteCommand extends LinePrefixCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '> ';
+    }
+}
 
-const headingLevel2Command = {
-    do: textCtrl => {
-        const initialState = textCtrl.getState();
-        setHeader(initialState, textCtrl, '## ');
-    },
-};
+class HeadingLevel1Command extends LinePrefixCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '# ';
+    }
+}
 
-const headingLevel3Command = {
-    do: textCtrl => {
-        const initialState = textCtrl.getState();
-        setHeader(initialState, textCtrl, '### ');
-    },
-};
+class HeadingLevel2Command extends LinePrefixCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '## ';
+    }
+}
 
-const headingLevel4Command = {
-    do: textCtrl => {
-        const initialState = textCtrl.getState();
-        setHeader(initialState, textCtrl, '#### ');
-    },
-};
+class HeadingLevel3Command extends LinePrefixCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '### ';
+    }
+}
 
-const headingLevel5Command = {
-    do: textCtrl => {
-        const initialState = textCtrl.getState();
-        setHeader(initialState, textCtrl, '##### ');
-    },
-};
+class HeadingLevel4Command extends LinePrefixCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '#### ';
+    }
+}
 
-const headingLevel6Command = {
-    do: textCtrl => {
-        const initialState = textCtrl.getState();
-        setHeader(initialState, textCtrl, '###### ');
-    },
-};
+class HeadingLevel5Command extends LinePrefixCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '##### ';
+    }
+}
+
+class HeadingLevel6Command extends LinePrefixCommand {
+    constructor() {
+        super(...arguments);
+        this.prefix = '###### ';
+    }
+}
+
+class UnorderedListCommand extends ListCommand {
+    getLinePrefix() {
+        return '- ';
+    }
+}
+
+class OrderedListCommand extends ListCommand {
+    getLinePrefix(_line, index) {
+        return `${index + 1}. `;
+    }
+}
+
+class CheckedListCommand extends ListCommand {
+    getLinePrefix() {
+        return '- [ ] ';
+    }
+}
 
-export { TextareaController, boldCommand, checkedListCommand, codeBlockCommand, codeCommand, header as headerHelpers, headingLevel1Command, headingLevel2Command, headingLevel3Command, headingLevel4Command, headingLevel5Command, headingLevel6Command, imageCommand, italicCommand, linkCommand, list as listHelpers, orderedListCommand, quoteCommand, strikethroughCommand, selectionAndText as textHelpers, unorderedListCommand, useTextAreaMarkdownEditor };
+export { BaseCommand, BoldCommand, CheckedListCommand, CodeBlockCommand, CodeCommand, HeadingLevel1Command, HeadingLevel2Command, HeadingLevel3Command, HeadingLevel4Command, HeadingLevel5Command, HeadingLevel6Command, ImageCommand, ItalicCommand, LinePrefixCommand, LinkCommand, ListCommand, OrderedListCommand, QuoteCommand, StrikethroughCommand, TextareaController, UnorderedListCommand, WrapCommand, selectionAndText as textHelpers, useTextAreaMarkdownEditor };
 //# sourceMappingURL=index.js.map