markdown-actions 1.1.2 → 1.2.0

package/README.md

@@ -71,6 +71,9 @@ hasFormat(textarea, 'bold') // Returns: true/false
 // Expand selection to word or line boundaries
 expandSelection(textarea, { toWord: true })
 
+// Find the spelling a document already uses (null when it uses none)
+detectMarkers('Hi *there*\n\n+ one') // Returns: { italic: '*', bold: null, bullet: '+' }
+
 // Apply custom markdown format
 applyCustomFormat(textarea, {
   prefix: '==',
@@ -82,6 +85,11 @@ applyCustomFormat(textarea, {
 ### Options
 
 ```javascript
+// Choose the spelling. Toggling off removes either spelling.
+toggleItalic(textarea, { marker: '*' })      // '_' (default) or '*'
+toggleBold(textarea, { marker: '__' })       // '**' (default) or '__'
+toggleBulletList(textarea, { marker: '*' })  // '-' (default), '*' or '+'
+
 // Link options
 insertLink(textarea, {
   url: 'https://example.com',  // Pre-fill URL
@@ -294,7 +302,7 @@ This careful selection management creates a professional editing experience:
 
 ## 🧪 Testing
 
-Open `test.html` in a browser to run the comprehensive test suite with 38 test cases covering:
+Run `npm test` for the Node tests (spellings, toggling, active formats). Open `test.html` in a browser to run the comprehensive test suite with 38 test cases covering:
 
 - All formatting functions
 - Edge cases and boundary conditions

package/dist/markdown-actions.esm.js

@@ -465,20 +465,20 @@ function undoOrderedListStyle(text) {
 }
 function undoUnorderedListStyle(text) {
   const lines = text.split("\n");
-  const unorderedListPrefix = "- ";
-  const shouldUndoUnorderedList = lines.every((line) => line.startsWith(unorderedListPrefix));
+  const unorderedListRegex = /^[-*+] /;
+  const shouldUndoUnorderedList = lines.every((line) => unorderedListRegex.test(line));
   let result = lines;
   if (shouldUndoUnorderedList) {
-    result = lines.map((line) => line.slice(unorderedListPrefix.length));
+    result = lines.map((line) => line.replace(unorderedListRegex, ""));
   }
   return {
     text: result.join("\n"),
     processed: shouldUndoUnorderedList
   };
 }
-function makePrefix(index, unorderedList) {
+function makePrefix(index, unorderedList, bulletMarker = "-") {
   if (unorderedList) {
-    return "- ";
+    return `${bulletMarker} `;
   } else {
     return `${index + 1}. `;
   }
@@ -506,7 +506,7 @@ function listStyle(textarea, style) {
   const selectedText = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
   const [undoResult, undoResultOppositeList, pristineText] = clearExistingListStyle(style, selectedText);
   const prefixedLines = pristineText.split("\n").map((value, index) => {
-    return `${makePrefix(index, style.unorderedList)}${value}`;
+    return `${makePrefix(index, style.unorderedList, style.bulletMarker)}${value}`;
   });
   const totalPrefixLength = prefixedLines.reduce((previousValue, _currentValue, currentIndex) => {
     return previousValue + makePrefix(currentIndex, style.unorderedList).length;
@@ -549,7 +549,7 @@ function applyListStyle(textarea, style) {
       adjustSelection: (isRemoving, selStart, selEnd, lineStart) => {
         const currentLine = textarea.value.slice(lineStart, textarea.selectionEnd);
         const orderedListRegex = /^\d+\.\s+/;
-        const unorderedListRegex = /^- /;
+        const unorderedListRegex = /^[-*+] /;
         const hasOrderedList = orderedListRegex.test(currentLine);
         const hasUnorderedList = unorderedListRegex.test(currentLine);
         const isRemovingCurrent = style.orderedList && hasOrderedList || style.unorderedList && hasUnorderedList;
@@ -624,8 +624,8 @@ function getActiveFormats(textarea) {
     }
     lineStart += line.length + 1;
   }
-  if (currentLine.startsWith("- ")) {
-    if (currentLine.startsWith("- [ ] ") || currentLine.startsWith("- [x] ")) {
+  if (/^[-*+] /.test(currentLine)) {
+    if (/^[-*+] \[[ xX]\] /.test(currentLine)) {
       formats.push("task-list");
     } else {
       formats.push("bullet-list");
@@ -646,36 +646,30 @@ function getActiveFormats(textarea) {
   const lookBehind = Math.max(0, selectionStart - 10);
   const lookAhead = Math.min(value.length, selectionEnd + 10);
   const surrounding = value.slice(lookBehind, lookAhead);
-  if (surrounding.includes("**")) {
-    const beforeCursor = value.slice(Math.max(0, selectionStart - 100), selectionStart);
-    const afterCursor = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100));
-    const lastOpenBold = beforeCursor.lastIndexOf("**");
-    const nextCloseBold = afterCursor.indexOf("**");
-    if (lastOpenBold !== -1 && nextCloseBold !== -1) {
-      formats.push("bold");
-    }
+  const beforeCursor = value.slice(Math.max(0, selectionStart - 100), selectionStart);
+  const afterCursor = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100));
+  if (["**", "__"].some((marker) => surrounding.includes(marker) && beforeCursor.lastIndexOf(marker) !== -1 && afterCursor.indexOf(marker) !== -1)) {
+    formats.push("bold");
   }
-  if (surrounding.includes("_")) {
-    const beforeCursor = value.slice(Math.max(0, selectionStart - 100), selectionStart);
-    const afterCursor = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100));
-    const lastOpenItalic = beforeCursor.lastIndexOf("_");
-    const nextCloseItalic = afterCursor.indexOf("_");
-    if (lastOpenItalic !== -1 && nextCloseItalic !== -1) {
-      formats.push("italic");
-    }
+  const singleMarker = (ch) => {
+    const c = ch === "*" ? "\\*" : ch;
+    return new RegExp(`(^|[^${c}])${c}[^${c}]*$`).test(beforeCursor) && new RegExp(`^[^${c}]*${c}(?!${c})`).test(afterCursor);
+  };
+  if (surrounding.includes("_") && singleMarker("_") || surrounding.includes("*") && singleMarker("*")) {
+    formats.push("italic");
   }
   if (surrounding.includes("`")) {
-    const beforeCursor = value.slice(Math.max(0, selectionStart - 100), selectionStart);
-    const afterCursor = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100));
-    if (beforeCursor.includes("`") && afterCursor.includes("`")) {
+    const beforeCursor2 = value.slice(Math.max(0, selectionStart - 100), selectionStart);
+    const afterCursor2 = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100));
+    if (beforeCursor2.includes("`") && afterCursor2.includes("`")) {
       formats.push("code");
     }
   }
   if (surrounding.includes("[") && surrounding.includes("]")) {
-    const beforeCursor = value.slice(Math.max(0, selectionStart - 100), selectionStart);
-    const afterCursor = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100));
-    const lastOpenBracket = beforeCursor.lastIndexOf("[");
-    const nextCloseBracket = afterCursor.indexOf("]");
+    const beforeCursor2 = value.slice(Math.max(0, selectionStart - 100), selectionStart);
+    const afterCursor2 = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100));
+    const lastOpenBracket = beforeCursor2.lastIndexOf("[");
+    const nextCloseBracket = afterCursor2.indexOf("]");
     if (lastOpenBracket !== -1 && nextCloseBracket !== -1) {
       const afterBracket = value.slice(selectionEnd + nextCloseBracket + 1, selectionEnd + nextCloseBracket + 10);
       if (afterBracket.startsWith("(")) {
@@ -723,23 +717,129 @@ function expandSelection(textarea, options = {}) {
   }
 }
 
+// src/operations/inline.js
+var isEmphasis = (ch) => ch === "*" || ch === "_";
+var OPENING_PUNCTUATION = /[(\[{"'“‘]/;
+var CLOSING_PUNCTUATION = /[.,;:!?)\]}"'”’]/;
+function carries(kind, n) {
+  return kind === "bold" ? n >= 2 : n % 2 === 1;
+}
+function runLength(text, ch, fromEnd) {
+  let n = 0;
+  while (n < text.length && text[fromEnd ? text.length - 1 - n : n] === ch)
+    n++;
+  return n;
+}
+function findWrap(value, start, end, kind) {
+  const size = kind === "bold" ? 2 : 1;
+  let open = start;
+  while (open > 0 && isEmphasis(value[open - 1]))
+    open--;
+  let close = end;
+  while (close < value.length && isEmphasis(value[close]))
+    close++;
+  const before = value.slice(open, start);
+  const after = value.slice(end, close);
+  for (const ch of ["*", "_"]) {
+    if (carries(kind, runLength(before, ch, true)) && carries(kind, runLength(after, ch, false))) {
+      return { open: start - size, close: end, size };
+    }
+    const outerBefore = runLength(before, ch, false);
+    if (outerBefore < before.length && carries(kind, outerBefore) && carries(kind, runLength(after, ch, true))) {
+      return { open, close: close - size, size };
+    }
+  }
+  return null;
+}
+function targetRange(value, selectionStart, selectionEnd) {
+  let start = selectionStart;
+  let end = selectionEnd;
+  if (start === end) {
+    start = wordSelectionStart(value, start);
+    end = wordSelectionEnd(value, end, false);
+    while (start < end && OPENING_PUNCTUATION.test(value[start]))
+      start++;
+    while (end > start && CLOSING_PUNCTUATION.test(value[end - 1]))
+      end--;
+  }
+  while (start < end && /\s/.test(value[start]))
+    start++;
+  while (end > start && /\s/.test(value[end - 1]))
+    end--;
+  while (start < end && isEmphasis(value[start]))
+    start++;
+  while (end > start && isEmphasis(value[end - 1]))
+    end--;
+  return { start, end };
+}
+var clamp = (n, low, high) => Math.min(Math.max(n, low), high);
+function inlineStyle(textarea, kind, marker) {
+  const value = textarea.value;
+  const caretStart = textarea.selectionStart;
+  const caretEnd = textarea.selectionEnd;
+  const hadSelection = caretStart !== caretEnd;
+  const { start, end } = targetRange(value, caretStart, caretEnd);
+  const wrap = start < end ? findWrap(value, start, end, kind) : null;
+  if (wrap) {
+    textarea.selectionStart = wrap.open;
+    textarea.selectionEnd = wrap.close + wrap.size;
+    const newStart = start - wrap.size;
+    const newEnd = end - wrap.size;
+    const caret2 = clamp(caretStart - wrap.size, newStart, newEnd);
+    return {
+      text: value.slice(wrap.open + wrap.size, wrap.close),
+      selectionStart: hadSelection ? newStart : caret2,
+      selectionEnd: hadSelection ? newEnd : caret2
+    };
+  }
+  textarea.selectionStart = start;
+  textarea.selectionEnd = end;
+  const caret = clamp(caretStart, start, end) + marker.length;
+  return {
+    text: marker + value.slice(start, end) + marker,
+    selectionStart: hadSelection ? start + marker.length : caret,
+    selectionEnd: hadSelection ? end + marker.length : caret
+  };
+}
+
+// src/core/markers.js
+var MARKERS = {
+  bold: ["**", "__"],
+  italic: ["_", "*"],
+  bullet: ["-", "*", "+"]
+};
+function resolveMarker(kind, marker) {
+  return MARKERS[kind].indexOf(marker) !== -1 ? marker : MARKERS[kind][0];
+}
+var DETECT = {
+  bullet: /^[ \t]*([-*+])[ \t]+\S/m,
+  bold: /(\*\*|__)(?=[^\s*_])[^\n]*?[^\s*_]\1/,
+  italic: /(?:^|[^*_\w])([*_])(?=[^\s*_])[^\n*_]*?[^\s*_]\1(?![*_\w])/
+};
+function detectMarkers(text) {
+  const found = {};
+  Object.keys(DETECT).forEach((kind) => {
+    const match = DETECT[kind].exec(text || "");
+    found[kind] = match ? match[1] : null;
+  });
+  return found;
+}
+
 // src/index.js
-function toggleBold(textarea) {
+function toggleBold(textarea, options = {}) {
   if (!textarea || textarea.disabled || textarea.readOnly)
     return;
   debugLog("toggleBold", "Starting");
   debugSelection(textarea, "Before");
-  const style = mergeWithDefaults(FORMATS.bold);
-  const result = blockStyle(textarea, style);
+  const result = inlineStyle(textarea, "bold", resolveMarker("bold", options.marker));
   debugResult(result);
   insertText(textarea, result);
   debugSelection(textarea, "After");
 }
-function toggleItalic(textarea) {
+function toggleItalic(textarea, options = {}) {
   if (!textarea || textarea.disabled || textarea.readOnly)
     return;
-  const style = mergeWithDefaults(FORMATS.italic);
-  const result = blockStyle(textarea, style);
+  const result = inlineStyle(textarea, "italic", resolveMarker("italic", options.marker));
   insertText(textarea, result);
 }
 function toggleCode(textarea) {
@@ -771,10 +871,11 @@ function insertLink(textarea, options = {}) {
   const result = blockStyle(textarea, style);
   insertText(textarea, result);
 }
-function toggleBulletList(textarea) {
+function toggleBulletList(textarea, options = {}) {
   if (!textarea || textarea.disabled || textarea.readOnly)
     return;
   const style = mergeWithDefaults(FORMATS.bulletList);
+  style.bulletMarker = resolveMarker("bullet", options.marker);
   applyListStyle(textarea, style);
 }
 function toggleNumberedList(textarea) {
@@ -957,6 +1058,7 @@ var src_default = {
   hasFormat: hasFormat2,
   expandSelection: expandSelection2,
   applyCustomFormat,
+  detectMarkers,
   preserveSelection,
   setUndoMethod,
   setDebugMode,
@@ -965,6 +1067,7 @@ var src_default = {
 export {
   applyCustomFormat,
   src_default as default,
+  detectMarkers,
   expandSelection2 as expandSelection,
   getActiveFormats2 as getActiveFormats,
   getDebugMode,