markdown-actions 1.0.0 → 1.0.2

package/dist/markdown-actions.esm.js

@@ -15,8 +15,58 @@ var __spreadValues = (a, b) => {
   return a;
 };
 
-// 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: "",
@@ -32,17 +82,155 @@ function getDefaultStyleArgs() {
     trimFirst: false
   };
 }
-function mergeStyleWithDefaults(style) {
-  return __spreadValues(__spreadValues({}, getDefaultStyleArgs()), style);
+function mergeWithDefaults(format) {
+  return __spreadValues(__spreadValues({}, getDefaultStyle()), format);
 }
 
-// src/core/selection-new.js
+// 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.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/)) {
@@ -67,7 +255,11 @@ function expandSelectionToLine(textarea) {
       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;
   }
@@ -95,19 +287,13 @@ function newlinesToSurroundSelectedText(textarea) {
   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 };
 }
@@ -120,64 +306,52 @@ function preserveSelection(textarea, callback) {
   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];
@@ -185,10 +359,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;
@@ -212,7 +386,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;
@@ -220,9 +394,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 {
@@ -232,18 +406,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;
@@ -254,7 +434,7 @@ function multilineStyle(textarea, arg) {
   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+/;
@@ -274,7 +454,7 @@ function undoUnorderedListStyle(text) {
   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"),
@@ -289,19 +469,19 @@ function makePrefix(index, unorderedList) {
   }
 }
 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;
@@ -309,14 +489,14 @@ function listStyle(textarea, style) {
   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) {
@@ -335,9 +515,9 @@ function listStyle(textarea, style) {
     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;
@@ -345,18 +525,10 @@ function listStyle(textarea, style) {
   }
   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);
 }
 
@@ -441,107 +613,146 @@ function hasFormat(textarea, format) {
   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--;
   }
@@ -551,12 +762,63 @@ function insertHeader(textarea, level = 1) {
   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);
@@ -564,32 +826,27 @@ function getActiveFormats2(textarea) {
 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,
@@ -597,29 +854,41 @@ var index_new_default = {
   toggleBulletList,
   toggleNumberedList,
   toggleQuote,
+  toggleTaskList,
   insertHeader,
+  toggleH1,
+  toggleH2,
+  toggleH3,
   getActiveFormats: getActiveFormats2,
   hasFormat: hasFormat2,
-  expandSelection,
+  expandSelection: expandSelection2,
   applyCustomFormat,
   preserveSelection,
-  setUndoMethod
+  setUndoMethod,
+  setDebugMode,
+  getDebugMode
 };
 export {
   applyCustomFormat,
-  index_new_default as default,
-  expandSelection,
+  src_default as default,
+  expandSelection2 as expandSelection,
   getActiveFormats2 as getActiveFormats,
+  getDebugMode,
   hasFormat2 as hasFormat,
   insertHeader,
   insertLink,
   preserveSelection,
+  setDebugMode,
   setUndoMethod,
   toggleBold,
   toggleBulletList,
   toggleCode,
+  toggleH1,
+  toggleH2,
+  toggleH3,
   toggleItalic,
   toggleNumberedList,
-  toggleQuote
+  toggleQuote,
+  toggleTaskList
 };
 //# sourceMappingURL=markdown-actions.esm.js.map