markdown-actions 1.0.0 → 1.0.2

package/dist/markdown-actions.js

@@ -31,28 +31,84 @@ var markdownActions = (() => {
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/index-new.js
-  var index_new_exports = {};
-  __export(index_new_exports, {
+  // src/index.js
+  var src_exports = {};
+  __export(src_exports, {
     applyCustomFormat: () => applyCustomFormat,
-    default: () => index_new_default,
-    expandSelection: () => expandSelection,
+    default: () => src_default,
+    expandSelection: () => expandSelection2,
     getActiveFormats: () => getActiveFormats2,
+    getDebugMode: () => getDebugMode,
     hasFormat: () => hasFormat2,
     insertHeader: () => insertHeader,
     insertLink: () => insertLink,
     preserveSelection: () => preserveSelection,
+    setDebugMode: () => setDebugMode,
     setUndoMethod: () => setUndoMethod,
     toggleBold: () => toggleBold,
     toggleBulletList: () => toggleBulletList,
     toggleCode: () => toggleCode,
+    toggleH1: () => toggleH1,
+    toggleH2: () => toggleH2,
+    toggleH3: () => toggleH3,
     toggleItalic: () => toggleItalic,
     toggleNumberedList: () => toggleNumberedList,
-    toggleQuote: () => toggleQuote
+    toggleQuote: () => toggleQuote,
+    toggleTaskList: () => toggleTaskList
   });
 
-  // src/core/style-args.js
-  function getDefaultStyleArgs() {
+  // src/core/formats.js
+  var FORMATS = {
+    bold: {
+      prefix: "**",
+      suffix: "**",
+      trimFirst: true
+    },
+    italic: {
+      prefix: "_",
+      suffix: "_",
+      trimFirst: true
+    },
+    code: {
+      prefix: "`",
+      suffix: "`",
+      blockPrefix: "```",
+      blockSuffix: "```"
+    },
+    link: {
+      prefix: "[",
+      suffix: "](url)",
+      replaceNext: "url",
+      scanFor: "https?://"
+    },
+    bulletList: {
+      prefix: "- ",
+      multiline: true,
+      unorderedList: true
+    },
+    numberedList: {
+      prefix: "1. ",
+      multiline: true,
+      orderedList: true
+    },
+    quote: {
+      prefix: "> ",
+      multiline: true,
+      surroundWithNewlines: true
+    },
+    taskList: {
+      prefix: "- [ ] ",
+      multiline: true,
+      surroundWithNewlines: true
+    },
+    header1: { prefix: "# " },
+    header2: { prefix: "## " },
+    header3: { prefix: "### " },
+    header4: { prefix: "#### " },
+    header5: { prefix: "##### " },
+    header6: { prefix: "###### " }
+  };
+  function getDefaultStyle() {
     return {
       prefix: "",
       suffix: "",
@@ -68,17 +124,155 @@ var markdownActions = (() => {
       trimFirst: false
     };
   }
-  function mergeStyleWithDefaults(style) {
-    return __spreadValues(__spreadValues({}, getDefaultStyleArgs()), style);
+  function mergeWithDefaults(format) {
+    return __spreadValues(__spreadValues({}, getDefaultStyle()), format);
+  }
+
+  // src/debug.js
+  var debugMode = false;
+  function setDebugMode(enabled) {
+    debugMode = enabled;
+  }
+  function getDebugMode() {
+    return debugMode;
+  }
+  function debugLog(funcName, message, data) {
+    if (!debugMode)
+      return;
+    console.group(`\u{1F50D} ${funcName}`);
+    console.log(message);
+    if (data) {
+      console.log("Data:", data);
+    }
+    console.groupEnd();
+  }
+  function debugSelection(textarea, label) {
+    if (!debugMode)
+      return;
+    const selected = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
+    console.group(`\u{1F4CD} Selection: ${label}`);
+    console.log("Position:", `${textarea.selectionStart}-${textarea.selectionEnd}`);
+    console.log("Selected text:", JSON.stringify(selected));
+    console.log("Length:", selected.length);
+    const before = textarea.value.slice(Math.max(0, textarea.selectionStart - 10), textarea.selectionStart);
+    const after = textarea.value.slice(textarea.selectionEnd, Math.min(textarea.value.length, textarea.selectionEnd + 10));
+    console.log("Context:", JSON.stringify(before) + "[SELECTION]" + JSON.stringify(after));
+    console.groupEnd();
+  }
+  function debugResult(result) {
+    if (!debugMode)
+      return;
+    console.group("\u{1F4DD} Result");
+    console.log("Text to insert:", JSON.stringify(result.text));
+    console.log("New selection:", `${result.selectionStart}-${result.selectionEnd}`);
+    console.groupEnd();
+  }
+
+  // src/core/insertion.js
+  var canInsertText = null;
+  function insertText(textarea, { text, selectionStart, selectionEnd }) {
+    const debugMode2 = getDebugMode();
+    if (debugMode2) {
+      console.group("\u{1F527} insertText");
+      console.log("Current selection:", `${textarea.selectionStart}-${textarea.selectionEnd}`);
+      console.log("Text to insert:", JSON.stringify(text));
+      console.log("New selection to set:", selectionStart, "-", selectionEnd);
+    }
+    textarea.focus();
+    const originalSelectionStart = textarea.selectionStart;
+    const originalSelectionEnd = textarea.selectionEnd;
+    const before = textarea.value.slice(0, originalSelectionStart);
+    const after = textarea.value.slice(originalSelectionEnd);
+    if (debugMode2) {
+      console.log("Before text (last 20):", JSON.stringify(before.slice(-20)));
+      console.log("After text (first 20):", JSON.stringify(after.slice(0, 20)));
+      console.log("Selected text being replaced:", JSON.stringify(textarea.value.slice(originalSelectionStart, originalSelectionEnd)));
+    }
+    const originalValue = textarea.value;
+    const hasSelection = originalSelectionStart !== originalSelectionEnd;
+    if (!hasSelection && (canInsertText === null || canInsertText === true)) {
+      textarea.contentEditable = "true";
+      try {
+        canInsertText = document.execCommand("insertText", false, text);
+      } catch (error) {
+        canInsertText = false;
+      }
+      textarea.contentEditable = "false";
+    } else if (hasSelection) {
+      if (debugMode2)
+        console.log("Has selection, skipping execCommand and using manual mode");
+      canInsertText = false;
+    }
+    if (debugMode2) {
+      console.log("canInsertText before:", canInsertText);
+      console.log("execCommand result:", canInsertText);
+    }
+    if (canInsertText) {
+      const expectedValue = before + text + after;
+      const actualValue = textarea.value;
+      if (debugMode2) {
+        console.log("Expected length:", expectedValue.length);
+        console.log("Actual length:", actualValue.length);
+      }
+      if (actualValue !== expectedValue) {
+        if (debugMode2) {
+          console.log("execCommand changed the value but not as expected");
+          console.log("Expected:", JSON.stringify(expectedValue.slice(0, 100)));
+          console.log("Actual:", JSON.stringify(actualValue.slice(0, 100)));
+        }
+      }
+    }
+    if (!canInsertText) {
+      if (debugMode2)
+        console.log("Using manual insertion");
+      if (textarea.value === originalValue) {
+        if (debugMode2)
+          console.log("Value unchanged, doing manual replacement");
+        try {
+          document.execCommand("ms-beginUndoUnit");
+        } catch (e) {
+        }
+        textarea.value = before + text + after;
+        try {
+          document.execCommand("ms-endUndoUnit");
+        } catch (e) {
+        }
+        textarea.dispatchEvent(new CustomEvent("input", { bubbles: true, cancelable: true }));
+      } else {
+        if (debugMode2)
+          console.log("Value was changed by execCommand, skipping manual insertion");
+      }
+    }
+    if (debugMode2)
+      console.log("Setting selection range:", selectionStart, selectionEnd);
+    if (selectionStart != null && selectionEnd != null) {
+      textarea.setSelectionRange(selectionStart, selectionEnd);
+    } else {
+      textarea.setSelectionRange(originalSelectionStart, textarea.selectionEnd);
+    }
+    if (debugMode2) {
+      console.log("Final value length:", textarea.value.length);
+      console.groupEnd();
+    }
+  }
+  function setUndoMethod(method) {
+    switch (method) {
+      case "native":
+        canInsertText = true;
+        break;
+      case "manual":
+        canInsertText = false;
+        break;
+      case "auto":
+        canInsertText = null;
+        break;
+    }
   }
 
-  // src/core/selection-new.js
+  // src/core/selection.js
   function isMultipleLines(string) {
     return string.trim().split("\n").length > 1;
   }
-  function repeat(string, n) {
-    return Array(n + 1).join(string);
-  }
   function wordSelectionStart(text, i) {
     let index = i;
     while (text[index] && text[index - 1] != null && !text[index - 1].match(/\s/)) {
@@ -103,7 +297,11 @@ var markdownActions = (() => {
         textarea.selectionStart = counter;
       }
       if (textarea.selectionEnd >= counter && textarea.selectionEnd < counter + lineLength) {
-        textarea.selectionEnd = counter + lineLength - 1;
+        if (index === lines.length - 1) {
+          textarea.selectionEnd = Math.min(counter + lines[index].length, textarea.value.length);
+        } else {
+          textarea.selectionEnd = counter + lineLength - 1;
+        }
       }
       counter += lineLength;
     }
@@ -131,19 +329,13 @@ var markdownActions = (() => {
     const breaksAfter = afterSelection.match(/^\n*/);
     const newlinesBeforeSelection = breaksBefore ? breaksBefore[0].length : 0;
     const newlinesAfterSelection = breaksAfter ? breaksAfter[0].length : 0;
-    let newlinesToAppend;
-    let newlinesToPrepend;
+    let newlinesToAppend = "";
+    let newlinesToPrepend = "";
     if (beforeSelection.match(/\S/) && newlinesBeforeSelection < 2) {
-      newlinesToAppend = repeat("\n", 2 - newlinesBeforeSelection);
+      newlinesToAppend = "\n".repeat(2 - newlinesBeforeSelection);
     }
     if (afterSelection.match(/\S/) && newlinesAfterSelection < 2) {
-      newlinesToPrepend = repeat("\n", 2 - newlinesAfterSelection);
-    }
-    if (newlinesToAppend == null) {
-      newlinesToAppend = "";
-    }
-    if (newlinesToPrepend == null) {
-      newlinesToPrepend = "";
+      newlinesToPrepend = "\n".repeat(2 - newlinesAfterSelection);
     }
     return { newlinesToAppend, newlinesToPrepend };
   }
@@ -156,64 +348,52 @@ var markdownActions = (() => {
     textarea.selectionEnd = end;
     textarea.scrollTop = scrollTop;
   }
-
-  // src/core/insertion-new.js
-  var canInsertText = null;
-  function insertText(textarea, { text, selectionStart, selectionEnd }) {
-    const originalSelectionStart = textarea.selectionStart;
-    const before = textarea.value.slice(0, originalSelectionStart);
-    const after = textarea.value.slice(textarea.selectionEnd);
-    if (canInsertText === null || canInsertText === true) {
-      textarea.contentEditable = "true";
-      try {
-        canInsertText = document.execCommand("insertText", false, text);
-      } catch (error) {
-        canInsertText = false;
-      }
-      textarea.contentEditable = "false";
-    }
-    if (canInsertText && !textarea.value.slice(0, textarea.selectionStart).endsWith(text)) {
-      canInsertText = false;
-    }
-    if (!canInsertText) {
-      try {
-        document.execCommand("ms-beginUndoUnit");
-      } catch (e) {
+  function applyLineOperation(textarea, operation, options = {}) {
+    const originalStart = textarea.selectionStart;
+    const originalEnd = textarea.selectionEnd;
+    const noInitialSelection = originalStart === originalEnd;
+    if (noInitialSelection) {
+      const value = textarea.value;
+      const start = originalStart;
+      let lineStart = start;
+      let lineEnd = start;
+      while (lineStart > 0 && value[lineStart - 1] !== "\n") {
+        lineStart--;
       }
-      textarea.value = before + text + after;
-      try {
-        document.execCommand("ms-endUndoUnit");
-      } catch (e) {
+      while (lineEnd < value.length && value[lineEnd] !== "\n") {
+        lineEnd++;
       }
-      textarea.dispatchEvent(new CustomEvent("input", { bubbles: true, cancelable: true }));
-    }
-    if (selectionStart != null && selectionEnd != null) {
-      textarea.setSelectionRange(selectionStart, selectionEnd);
+      textarea.selectionStart = lineStart;
+      textarea.selectionEnd = lineEnd;
     } else {
-      textarea.setSelectionRange(originalSelectionStart, textarea.selectionEnd);
+      expandSelectionToLine(textarea);
     }
-  }
-  function setUndoMethod(method) {
-    if (method === "native") {
-      canInsertText = true;
-    } else if (method === "manual") {
-      canInsertText = false;
-    } else {
-      canInsertText = null;
+    const result = operation(textarea);
+    if (noInitialSelection && options.prefix) {
+      const selectedText = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
+      const isRemoving = selectedText.startsWith(options.prefix);
+      if (isRemoving) {
+        result.selectionStart = Math.max(originalStart - options.prefix.length, textarea.selectionStart);
+        result.selectionEnd = result.selectionStart;
+      } else {
+        result.selectionStart = originalStart + options.prefix.length;
+        result.selectionEnd = result.selectionStart;
+      }
     }
+    return result;
   }
 
-  // src/operations/block-new.js
-  function blockStyle(textarea, arg) {
+  // src/operations/block.js
+  function blockStyle(textarea, style) {
     let newlinesToAppend;
     let newlinesToPrepend;
-    const { prefix, suffix, blockPrefix, blockSuffix, replaceNext, prefixSpace, scanFor, surroundWithNewlines } = arg;
+    const { prefix, suffix, blockPrefix, blockSuffix, replaceNext, prefixSpace, scanFor, surroundWithNewlines, trimFirst } = style;
     const originalSelectionStart = textarea.selectionStart;
     const originalSelectionEnd = textarea.selectionEnd;
     let selectedText = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
-    let prefixToUse = isMultipleLines(selectedText) && blockPrefix.length > 0 ? `${blockPrefix}
+    let prefixToUse = isMultipleLines(selectedText) && blockPrefix && blockPrefix.length > 0 ? `${blockPrefix}
 ` : prefix;
-    let suffixToUse = isMultipleLines(selectedText) && blockSuffix.length > 0 ? `
+    let suffixToUse = isMultipleLines(selectedText) && blockSuffix && blockSuffix.length > 0 ? `
 ${blockSuffix}` : suffix;
     if (prefixSpace) {
       const beforeSelection = textarea.value[textarea.selectionStart - 1];
@@ -221,10 +401,10 @@ ${blockSuffix}` : suffix;
         prefixToUse = ` ${prefixToUse}`;
       }
     }
-    selectedText = expandSelectedText(textarea, prefixToUse, suffixToUse, arg.multiline);
+    selectedText = expandSelectedText(textarea, prefixToUse, suffixToUse, style.multiline);
     let selectionStart = textarea.selectionStart;
     let selectionEnd = textarea.selectionEnd;
-    const hasReplaceNext = replaceNext.length > 0 && suffixToUse.indexOf(replaceNext) > -1 && selectedText.length > 0;
+    const hasReplaceNext = replaceNext && replaceNext.length > 0 && suffixToUse.indexOf(replaceNext) > -1 && selectedText.length > 0;
     if (surroundWithNewlines) {
       const ref = newlinesToSurroundSelectedText(textarea);
       newlinesToAppend = ref.newlinesToAppend;
@@ -248,7 +428,7 @@ ${blockSuffix}` : suffix;
       selectionStart = originalSelectionStart + prefixToUse.length;
       selectionEnd = originalSelectionEnd + prefixToUse.length;
       const whitespaceEdges = selectedText.match(/^\s*|\s*$/g);
-      if (arg.trimFirst && whitespaceEdges) {
+      if (trimFirst && whitespaceEdges) {
         const leadingWhitespace = whitespaceEdges[0] || "";
         const trailingWhitespace = whitespaceEdges[1] || "";
         replacementText = leadingWhitespace + prefixToUse + selectedText.trim() + suffixToUse + trailingWhitespace;
@@ -256,9 +436,9 @@ ${blockSuffix}` : suffix;
         selectionEnd -= trailingWhitespace.length;
       }
       return { text: replacementText, selectionStart, selectionEnd };
-    } else if (scanFor.length > 0 && selectedText.match(scanFor)) {
+    } else if (scanFor && scanFor.length > 0 && selectedText.match(scanFor)) {
       suffixToUse = suffixToUse.replace(replaceNext, selectedText);
-      const replacementText = prefixToUse + selectedText + suffixToUse;
+      const replacementText = prefixToUse + suffixToUse;
       selectionStart = selectionEnd = selectionStart + prefixToUse.length;
       return { text: replacementText, selectionStart, selectionEnd };
     } else {
@@ -268,18 +448,24 @@ ${blockSuffix}` : suffix;
       return { text: replacementText, selectionStart, selectionEnd };
     }
   }
-  function multilineStyle(textarea, arg) {
-    const { prefix, suffix, surroundWithNewlines } = arg;
+  function multilineStyle(textarea, style) {
+    const { prefix, suffix, surroundWithNewlines } = style;
     let text = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
     let selectionStart = textarea.selectionStart;
     let selectionEnd = textarea.selectionEnd;
     const lines = text.split("\n");
-    const undoStyle = lines.every((line) => line.startsWith(prefix) && line.endsWith(suffix));
+    const undoStyle = lines.every((line) => line.startsWith(prefix) && (!suffix || line.endsWith(suffix)));
     if (undoStyle) {
-      text = lines.map((line) => line.slice(prefix.length, line.length - suffix.length)).join("\n");
+      text = lines.map((line) => {
+        let result = line.slice(prefix.length);
+        if (suffix) {
+          result = result.slice(0, result.length - suffix.length);
+        }
+        return result;
+      }).join("\n");
       selectionEnd = selectionStart + text.length;
     } else {
-      text = lines.map((line) => prefix + line + suffix).join("\n");
+      text = lines.map((line) => prefix + line + (suffix || "")).join("\n");
       if (surroundWithNewlines) {
         const { newlinesToAppend, newlinesToPrepend } = newlinesToSurroundSelectedText(textarea);
         selectionStart += newlinesToAppend.length;
@@ -290,7 +476,7 @@ ${blockSuffix}` : suffix;
     return { text, selectionStart, selectionEnd };
   }
 
-  // src/operations/list-new.js
+  // src/operations/list.js
   function undoOrderedListStyle(text) {
     const lines = text.split("\n");
     const orderedListRegex = /^\d+\.\s+/;
@@ -310,7 +496,7 @@ ${blockSuffix}` : suffix;
     const shouldUndoUnorderedList = lines.every((line) => line.startsWith(unorderedListPrefix));
     let result = lines;
     if (shouldUndoUnorderedList) {
-      result = lines.map((line) => line.slice(unorderedListPrefix.length, line.length));
+      result = lines.map((line) => line.slice(unorderedListPrefix.length));
     }
     return {
       text: result.join("\n"),
@@ -325,19 +511,19 @@ ${blockSuffix}` : suffix;
     }
   }
   function clearExistingListStyle(style, selectedText) {
-    let undoResultOpositeList;
     let undoResult;
+    let undoResultOppositeList;
     let pristineText;
     if (style.orderedList) {
       undoResult = undoOrderedListStyle(selectedText);
-      undoResultOpositeList = undoUnorderedListStyle(undoResult.text);
-      pristineText = undoResultOpositeList.text;
+      undoResultOppositeList = undoUnorderedListStyle(undoResult.text);
+      pristineText = undoResultOppositeList.text;
     } else {
       undoResult = undoUnorderedListStyle(selectedText);
-      undoResultOpositeList = undoOrderedListStyle(undoResult.text);
-      pristineText = undoResultOpositeList.text;
+      undoResultOppositeList = undoOrderedListStyle(undoResult.text);
+      pristineText = undoResultOppositeList.text;
     }
-    return [undoResult, undoResultOpositeList, pristineText];
+    return [undoResult, undoResultOppositeList, pristineText];
   }
   function listStyle(textarea, style) {
     const noInitialSelection = textarea.selectionStart === textarea.selectionEnd;
@@ -345,14 +531,14 @@ ${blockSuffix}` : suffix;
     let selectionEnd = textarea.selectionEnd;
     expandSelectionToLine(textarea);
     const selectedText = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
-    const [undoResult, undoResultOpositeList, pristineText] = clearExistingListStyle(style, selectedText);
+    const [undoResult, undoResultOppositeList, pristineText] = clearExistingListStyle(style, selectedText);
     const prefixedLines = pristineText.split("\n").map((value, index) => {
       return `${makePrefix(index, style.unorderedList)}${value}`;
     });
     const totalPrefixLength = prefixedLines.reduce((previousValue, _currentValue, currentIndex) => {
       return previousValue + makePrefix(currentIndex, style.unorderedList).length;
     }, 0);
-    const totalPrefixLengthOpositeList = prefixedLines.reduce((previousValue, _currentValue, currentIndex) => {
+    const totalPrefixLengthOppositeList = prefixedLines.reduce((previousValue, _currentValue, currentIndex) => {
       return previousValue + makePrefix(currentIndex, !style.unorderedList).length;
     }, 0);
     if (undoResult.processed) {
@@ -371,9 +557,9 @@ ${blockSuffix}` : suffix;
       selectionStart = Math.max(selectionStart + makePrefix(0, style.unorderedList).length + newlinesToAppend.length, 0);
       selectionEnd = selectionStart;
     } else {
-      if (undoResultOpositeList.processed) {
+      if (undoResultOppositeList.processed) {
         selectionStart = Math.max(textarea.selectionStart + newlinesToAppend.length, 0);
-        selectionEnd = textarea.selectionEnd + newlinesToAppend.length + totalPrefixLength - totalPrefixLengthOpositeList;
+        selectionEnd = textarea.selectionEnd + newlinesToAppend.length + totalPrefixLength - totalPrefixLengthOppositeList;
       } else {
         selectionStart = Math.max(textarea.selectionStart + newlinesToAppend.length, 0);
         selectionEnd = textarea.selectionEnd + newlinesToAppend.length + totalPrefixLength;
@@ -381,18 +567,10 @@ ${blockSuffix}` : suffix;
     }
     return { text, selectionStart, selectionEnd };
   }
-
-  // src/core/style-text.js
-  function styleSelectedText(textarea, styleArgs) {
-    const text = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
-    let result;
-    if (styleArgs.orderedList || styleArgs.unorderedList) {
-      result = listStyle(textarea, styleArgs);
-    } else if (styleArgs.multiline && isMultipleLines(text)) {
-      result = multilineStyle(textarea, styleArgs);
-    } else {
-      result = blockStyle(textarea, styleArgs);
-    }
+  function applyListStyle(textarea, style) {
+    const originalStart = textarea.selectionStart;
+    const originalEnd = textarea.selectionEnd;
+    const result = listStyle(textarea, style);
     insertText(textarea, result);
   }
 
@@ -477,107 +655,146 @@ ${blockSuffix}` : suffix;
     const activeFormats = getActiveFormats(textarea);
     return activeFormats.includes(format);
   }
-
-  // src/index-new.js
-  var FORMATS2 = {
-    bold: { prefix: "**", suffix: "**", trimFirst: true },
-    italic: { prefix: "_", suffix: "_", trimFirst: true },
-    code: {
-      prefix: "`",
-      suffix: "`",
-      blockPrefix: "```",
-      blockSuffix: "```"
-    },
-    link: {
-      prefix: "[",
-      suffix: "](url)",
-      replaceNext: "url",
-      scanFor: "https?://"
-    },
-    quote: {
-      prefix: "> ",
-      multiline: true,
-      surroundWithNewlines: true
-    },
-    bulletList: {
-      prefix: "- ",
-      multiline: true,
-      unorderedList: true
-    },
-    numberedList: {
-      prefix: "1. ",
-      multiline: true,
-      orderedList: true
-    },
-    header1: { prefix: "# " },
-    header2: { prefix: "## " },
-    header3: { prefix: "### " },
-    header4: { prefix: "#### " },
-    header5: { prefix: "##### " },
-    header6: { prefix: "###### " }
-  };
-  function applyStyle(textarea, format) {
-    const style = mergeStyleWithDefaults(format);
-    textarea.focus();
-    styleSelectedText(textarea, style);
+  function expandSelection(textarea, options = {}) {
+    if (!textarea)
+      return;
+    const { toWord, toLine, toFormat } = options;
+    const { selectionStart, selectionEnd, value } = textarea;
+    if (toLine) {
+      const lines = value.split("\n");
+      let lineStart = 0;
+      let lineEnd = 0;
+      let currentPos = 0;
+      for (const line of lines) {
+        if (selectionStart >= currentPos && selectionStart <= currentPos + line.length) {
+          lineStart = currentPos;
+          lineEnd = currentPos + line.length;
+          break;
+        }
+        currentPos += line.length + 1;
+      }
+      textarea.selectionStart = lineStart;
+      textarea.selectionEnd = lineEnd;
+    } else if (toWord && selectionStart === selectionEnd) {
+      let start = selectionStart;
+      let end = selectionEnd;
+      while (start > 0 && !/\s/.test(value[start - 1])) {
+        start--;
+      }
+      while (end < value.length && !/\s/.test(value[end])) {
+        end++;
+      }
+      textarea.selectionStart = start;
+      textarea.selectionEnd = end;
+    }
   }
+
+  // src/index.js
   function toggleBold(textarea) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
-    applyStyle(textarea, FORMATS2.bold);
+    debugLog("toggleBold", "Starting");
+    debugSelection(textarea, "Before");
+    const style = mergeWithDefaults(FORMATS.bold);
+    const result = blockStyle(textarea, style);
+    debugResult(result);
+    insertText(textarea, result);
+    debugSelection(textarea, "After");
   }
   function toggleItalic(textarea) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
-    applyStyle(textarea, FORMATS2.italic);
+    const style = mergeWithDefaults(FORMATS.italic);
+    const result = blockStyle(textarea, style);
+    insertText(textarea, result);
   }
   function toggleCode(textarea) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
-    applyStyle(textarea, FORMATS2.code);
+    const selectedText = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
+    const style = mergeWithDefaults(FORMATS.code);
+    let result;
+    if (isMultipleLines(selectedText)) {
+      const blockStyle2 = {
+        prefix: "```\n",
+        suffix: "\n```",
+        surroundWithNewlines: true
+      };
+      result = multilineStyle(textarea, mergeWithDefaults(blockStyle2));
+    } else {
+      result = blockStyle(textarea, style);
+    }
+    insertText(textarea, result);
   }
   function insertLink(textarea, options = {}) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
-    let format = __spreadValues({}, FORMATS2.link);
+    const selectedText = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
+    let style = mergeWithDefaults(FORMATS.link);
     if (options.url) {
-      format.suffix = `](${options.url})`;
-      format.replaceNext = "";
+      style.suffix = `](${options.url})`;
+      style.replaceNext = "";
     }
-    if (options.text && !textarea.value.slice(textarea.selectionStart, textarea.selectionEnd)) {
+    if (options.text && !selectedText) {
       const pos = textarea.selectionStart;
       textarea.value = textarea.value.slice(0, pos) + options.text + textarea.value.slice(pos);
       textarea.selectionStart = pos;
       textarea.selectionEnd = pos + options.text.length;
     }
-    applyStyle(textarea, format);
+    const result = blockStyle(textarea, style);
+    insertText(textarea, result);
   }
   function toggleBulletList(textarea) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
-    applyStyle(textarea, FORMATS2.bulletList);
+    const style = mergeWithDefaults(FORMATS.bulletList);
+    applyListStyle(textarea, style);
   }
   function toggleNumberedList(textarea) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
-    applyStyle(textarea, FORMATS2.numberedList);
+    const style = mergeWithDefaults(FORMATS.numberedList);
+    applyListStyle(textarea, style);
   }
   function toggleQuote(textarea) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
-    applyStyle(textarea, FORMATS2.quote);
+    debugLog("toggleQuote", "Starting");
+    debugSelection(textarea, "Initial");
+    const style = mergeWithDefaults(FORMATS.quote);
+    const result = applyLineOperation(
+      textarea,
+      (ta) => multilineStyle(ta, style),
+      { prefix: style.prefix }
+    );
+    debugResult(result);
+    insertText(textarea, result);
+    debugSelection(textarea, "Final");
   }
-  function insertHeader(textarea, level = 1) {
+  function toggleTaskList(textarea) {
+    if (!textarea || textarea.disabled || textarea.readOnly)
+      return;
+    const style = mergeWithDefaults(FORMATS.taskList);
+    const result = applyLineOperation(
+      textarea,
+      (ta) => multilineStyle(ta, style),
+      { prefix: style.prefix }
+    );
+    insertText(textarea, result);
+  }
+  function insertHeader(textarea, level = 1, toggle = false) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
     if (level < 1 || level > 6)
       level = 1;
-    const headerKey = `header${level}`;
-    const format = FORMATS2[headerKey] || FORMATS2.header1;
+    const originalStart = textarea.selectionStart;
+    const originalEnd = textarea.selectionEnd;
+    const noInitialSelection = originalStart === originalEnd;
+    const headerKey = `header${level === 1 ? "1" : level}`;
+    const style = mergeWithDefaults(FORMATS[headerKey] || FORMATS.header1);
     const value = textarea.value;
-    const start = textarea.selectionStart;
-    let lineStart = start;
-    let lineEnd = start;
+    let lineStart = originalStart;
+    let lineEnd = originalStart;
     while (lineStart > 0 && value[lineStart - 1] !== "\n") {
       lineStart--;
     }
@@ -587,12 +804,63 @@ ${blockSuffix}` : suffix;
     textarea.selectionStart = lineStart;
     textarea.selectionEnd = lineEnd;
     const currentLine = value.slice(lineStart, lineEnd);
+    const existingHeaderMatch = currentLine.match(/^(#{1,6})\s*/);
+    const existingPrefixLength = existingHeaderMatch ? existingHeaderMatch[0].length : 0;
+    const existingLevel = existingHeaderMatch ? existingHeaderMatch[1].length : 0;
     const cleanedLine = currentLine.replace(/^#{1,6}\s*/, "");
-    const newLine = format.prefix + cleanedLine;
-    const tempSelection = textarea.selectionStart;
-    textarea.value = value.slice(0, lineStart) + newLine + value.slice(lineEnd);
-    textarea.selectionStart = lineStart + format.prefix.length;
-    textarea.selectionEnd = lineStart + newLine.length;
+    let newLine;
+    let isRemoving = false;
+    if (toggle && existingLevel === level) {
+      newLine = cleanedLine;
+      isRemoving = true;
+    } else {
+      newLine = style.prefix + cleanedLine;
+    }
+    let selectionStart, selectionEnd;
+    if (noInitialSelection) {
+      const cursorOffsetInLine = originalStart - lineStart;
+      if (isRemoving) {
+        if (cursorOffsetInLine < existingPrefixLength) {
+          selectionStart = lineStart;
+        } else {
+          selectionStart = originalStart - existingPrefixLength;
+        }
+      } else if (existingPrefixLength > 0) {
+        if (cursorOffsetInLine < existingPrefixLength) {
+          selectionStart = lineStart + Math.min(cursorOffsetInLine, style.prefix.length);
+        } else {
+          const prefixDiff = style.prefix.length - existingPrefixLength;
+          selectionStart = originalStart + prefixDiff;
+        }
+      } else {
+        selectionStart = originalStart + style.prefix.length;
+      }
+      selectionStart = Math.min(selectionStart, lineStart + newLine.length);
+      selectionEnd = selectionStart;
+    } else {
+      if (isRemoving) {
+        selectionStart = lineStart;
+        selectionEnd = lineStart + newLine.length;
+      } else {
+        selectionStart = lineStart + style.prefix.length;
+        selectionEnd = lineStart + newLine.length;
+      }
+    }
+    const result = {
+      text: newLine,
+      selectionStart,
+      selectionEnd
+    };
+    insertText(textarea, result);
+  }
+  function toggleH1(textarea) {
+    insertHeader(textarea, 1, true);
+  }
+  function toggleH2(textarea) {
+    insertHeader(textarea, 2, true);
+  }
+  function toggleH3(textarea) {
+    insertHeader(textarea, 3, true);
   }
   function getActiveFormats2(textarea) {
     return getActiveFormats(textarea);
@@ -600,32 +868,27 @@ ${blockSuffix}` : suffix;
   function hasFormat2(textarea, format) {
     return hasFormat(textarea, format);
   }
-  function expandSelection(textarea, options = {}) {
-    if (!textarea)
-      return;
-    const { toWord, toLine } = options;
-    const { selectionStart, selectionEnd, value } = textarea;
-    if (toLine) {
-      expandSelectionToLine(textarea);
-    } else if (toWord && selectionStart === selectionEnd) {
-      let start = selectionStart;
-      let end = selectionEnd;
-      while (start > 0 && !/\s/.test(value[start - 1])) {
-        start--;
-      }
-      while (end < value.length && !/\s/.test(value[end])) {
-        end++;
-      }
-      textarea.selectionStart = start;
-      textarea.selectionEnd = end;
-    }
+  function expandSelection2(textarea, options = {}) {
+    expandSelection(textarea, options);
   }
   function applyCustomFormat(textarea, format) {
     if (!textarea || textarea.disabled || textarea.readOnly)
       return;
-    applyStyle(textarea, format);
+    const style = mergeWithDefaults(format);
+    let result;
+    if (style.multiline) {
+      const selectedText = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
+      if (isMultipleLines(selectedText)) {
+        result = multilineStyle(textarea, style);
+      } else {
+        result = blockStyle(textarea, style);
+      }
+    } else {
+      result = blockStyle(textarea, style);
+    }
+    insertText(textarea, result);
   }
-  var index_new_default = {
+  var src_default = {
     toggleBold,
     toggleItalic,
     toggleCode,
@@ -633,14 +896,20 @@ ${blockSuffix}` : suffix;
     toggleBulletList,
     toggleNumberedList,
     toggleQuote,
+    toggleTaskList,
     insertHeader,
+    toggleH1,
+    toggleH2,
+    toggleH3,
     getActiveFormats: getActiveFormats2,
     hasFormat: hasFormat2,
-    expandSelection,
+    expandSelection: expandSelection2,
     applyCustomFormat,
     preserveSelection,
-    setUndoMethod
+    setUndoMethod,
+    setDebugMode,
+    getDebugMode
   };
-  return __toCommonJS(index_new_exports);
+  return __toCommonJS(src_exports);
 })();
 //# sourceMappingURL=markdown-actions.js.map