autumnnote 1.2.1 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autumnnote",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "A modern, lightweight WYSIWYG editor — built with vanilla JavaScript, no jQuery required.",
   "main": "dist/autumnnote.umd.js",
   "module": "dist/autumnnote.es.js",

package/src/js/core/dom.js

@@ -204,13 +204,16 @@ export function nodeValue(node) {
 }
 
 /**
- * Returns true if a node is empty (no visible content).
- * @param {Node} node
- * @returns {boolean}
+ * Determine whether a DOM node contains no visible content.
+ *
+ * Text nodes are considered empty when their `nodeValue` is empty. Void elements (e.g., `img`, `br`, `input`) are considered non-empty. An element with exactly one `<br>` child is treated as empty. For other elements, emptiness means trimmed `textContent` is empty and there are no descendant `img`, `video`, `hr`, or `table` elements.
+ * @param {Node} node - Node to inspect for visible content.
+ * @returns {boolean} `true` if the node has no visible content, `false` otherwise.
  */
 export function isEmpty(node) {
   if (isText(node)) return !node.nodeValue;
   if (isVoid(node)) return false;
+  if (node.childNodes.length === 1 && node.firstChild?.nodeName === 'BR') return true;
   return !node.textContent.trim() && !node.querySelector('img, video, hr, table');
 }
 

package/src/js/core/func.js

@@ -29,19 +29,30 @@ export function debounce(fn, delay) {
 }
 
 /**
- * Throttle a function call.
- * @param {Function} fn
- * @param {number} limit - milliseconds
- * @returns {Function}
+ * Create a wrapper that limits how often `fn` can be invoked while ensuring the last call in a burst is executed.
+ * @param {Function} fn - Function to be throttled.
+ * @param {number} limit - Time window in milliseconds during which at most one call is allowed.
+ * @returns {Function} A wrapper function that invokes `fn` at most once per `limit` milliseconds; calls preserve `this` and original arguments and schedule a trailing invocation for the final call in a burst.
  */
 export function throttle(fn, limit) {
-  let lastCall = 0;
+  let lastCall = -Infinity;
+  let trailingTimer = null;
   return function (...args) {
-    const now = Date.now();
-    if (now - lastCall >= limit) {
+    const now = performance.now();
+    const elapsed = now - lastCall;
+    if (elapsed >= limit) {
       lastCall = now;
+      clearTimeout(trailingTimer);
+      trailingTimer = null;
       return fn.apply(this, args);
     }
+    // Ensure the final event in a burst is not dropped
+    clearTimeout(trailingTimer);
+    trailingTimer = setTimeout(() => {
+      lastCall = performance.now();
+      trailingTimer = null;
+      fn.apply(this, args);
+    }, limit - elapsed);
   };
 }
 
@@ -143,11 +154,11 @@ export function isPlainObject(val) {
 export function rect2bnd(rect) {
   if (!rect) return null;
   return {
-    top: Math.round(rect.top),
-    left: Math.round(rect.left),
-    width: Math.round(rect.width),
-    height: Math.round(rect.height),
-    bottom: Math.round(rect.bottom),
-    right: Math.round(rect.right),
+    top: rect.top,
+    left: rect.left,
+    width: rect.width,
+    height: rect.height,
+    bottom: rect.bottom,
+    right: rect.right,
   };
 }

package/src/js/core/markdown.js

@@ -20,14 +20,25 @@ export function htmlToMarkdown(html) {
   return _domToMd(doc.body).replace(/\n{3,}/g, '\n\n').trim();
 }
 
-function _domToMd(node) {
+/**
+ * Convert a DOM node subtree into Markdown.
+ *
+ * Recursively produces a Markdown string representing the given DOM node and its descendants,
+ * handling common HTML constructs such as paragraphs, headings, lists (with nested indentation),
+ * blockquotes, fenced and inline code, links, images, tables, horizontal rules, and basic inline emphasis.
+ *
+ * @param {Node} node - The DOM node to convert.
+ * @param {number} [depth=0] - Current nesting depth used to indent nested list items.
+ * @returns {string} The Markdown representation of the node subtree.
+ */
+function _domToMd(node, depth = 0) {
   if (node.nodeType === 3) {
     return node.textContent.replace(/\s+/g, ' ');
   }
   if (node.nodeType !== 1) return '';
 
   const tag = node.nodeName.toLowerCase();
-  const inner = () => Array.from(node.childNodes).map(_domToMd).join('');
+  const inner = () => Array.from(node.childNodes).map(n => _domToMd(n, depth)).join('');
 
   switch (tag) {
     case 'p':
@@ -76,12 +87,16 @@ function _domToMd(node) {
     case 'ul': {
       const items = Array.from(node.querySelectorAll(':scope > li'));
       if (!items.length) return inner();
-      return `\n\n${items.map((li) => `- ${_domToMd(li).trim()}`).join('\n')}\n\n`;
+      const indent = '  '.repeat(depth);
+      const lines = items.map((li) => `${indent}- ${_domToMd(li, depth + 1).trim()}`).join('\n');
+      return depth === 0 ? `\n\n${lines}\n\n` : `\n${lines}`;
     }
     case 'ol': {
       const items = Array.from(node.querySelectorAll(':scope > li'));
       if (!items.length) return inner();
-      return `\n\n${items.map((li, i) => `${i + 1}. ${_domToMd(li).trim()}`).join('\n')}\n\n`;
+      const indent = '  '.repeat(depth);
+      const lines = items.map((li, i) => `${indent}${i + 1}. ${_domToMd(li, depth + 1).trim()}`).join('\n');
+      return depth === 0 ? `\n\n${lines}\n\n` : `\n${lines}`;
     }
     case 'li':  return inner();
     case 'hr':  return '\n\n---\n\n';
@@ -106,12 +121,15 @@ function _domToMd(node) {
 }
 
 /**
- * Returns true if the text contains recognisable Markdown patterns.
- * @param {string} text
- * @returns {boolean}
+ * Detects whether a string likely contains Markdown syntax.
+ *
+ * Checks for common Markdown constructs such as ATX headings, unordered or
+ * ordered list items, blockquotes, fenced code blocks, and bold emphasis.
+ * @param {string} text - Input text to inspect for Markdown patterns.
+ * @returns {boolean} `true` if any Markdown-like pattern is present, `false` otherwise.
  */
 export function isMarkdown(text) {
-  return /^#{1,6} \S|^\s*[-*+] \S|^\s*\d+\. \S|^> \S|\*{2}.+?\*{2}|^```/m.test(text);
+  return /^#{1,6} \S|^\s*[-*+] \S|^\s*\d+\. \S|^> \S|^```|^\*{2}.+?\*{2}/m.test(text);
 }
 
 /**

package/src/js/core/sanitise.js

@@ -6,7 +6,10 @@
  */
 
 /** Tags that are unconditionally removed from editor content. */
-const PROHIBITED_TAGS = ['script', 'style', 'iframe', 'object', 'embed', 'form', 'button'];
+const PROHIBITED_TAGS = ['script', 'style', 'iframe', 'object', 'embed', 'form', 'base'];
+
+/** Tags whose element wrapper is stripped but content (child nodes) is preserved. */
+const UNWRAP_TAGS = new Set(['button']);
 
 /** Attributes whose values must be sanitised as URLs. */
 const URL_ATTRS = ['href', 'src', 'action', 'formaction'];
@@ -22,82 +25,90 @@ const TRUSTED_IFRAME_HOSTS = new Set([
 ]);
 
 /**
- * Sanitises an HTML string by removing dangerous elements and attributes.
- * Uses DOMParser so the sanitisation follows normal browser parsing rules —
- * no regex shortcuts that can be bypassed by encoding tricks.
+ * Produce a sanitized HTML string with dangerous elements and attributes removed.
  *
- * - Strips PROHIBITED_TAGS (script, style, iframe, object, embed, form, button)
- * - Allows input[type="checkbox"] only inside ul.an-checklist li; removes all other <input>
- * - Removes all on* event-handler attributes
- * - Rejects javascript: and vbscript: URLs in URL attributes
- * - Rejects data: URIs everywhere except img[src] (base64 uploads)
+ * Removes disallowed tags and wrappers, strips event-handler attributes, rejects
+ * `javascript:`/`vbscript:` URLs and most `data:` URIs, restricts iframe `src`
+ * to trusted hosts when enabled, and permits only checklist checkboxes as inputs.
  *
- * @param {string} html
- * @returns {string}
+ * @param {string} html - HTML fragment to sanitize.
+ * @param {Object} [options]
+ * @param {boolean} [options.allowIframes=false] - If true, `iframe` elements are not removed but their `src` is restricted to trusted hosts and `srcdoc` is removed.
+ * @returns {string} The sanitized HTML fragment.
  */
 export function sanitiseHTML(html, { allowIframes = false } = {}) {
   const doc = new DOMParser().parseFromString(`<body>${html || ''}</body>`, 'text/html');
 
-  // Remove outright dangerous elements (optionally preserve iframes for video embeds)
-  const tags = allowIframes ? PROHIBITED_TAGS.filter((t) => t !== 'iframe') : PROHIBITED_TAGS;
-  tags.forEach((tag) => {
-    doc.querySelectorAll(tag).forEach((el) => el.remove());
-  });
+  // Single querySelectorAll pass — collect all elements once to avoid
+  // repeated full-tree traversals for each category of check.
+  const allElements = Array.from(doc.querySelectorAll('*'));
+
+  // Build the prohibited tag set for fast O(1) lookup
+  const prohibited = new Set(
+    allowIframes ? PROHIBITED_TAGS.filter((t) => t !== 'iframe') : PROHIBITED_TAGS,
+  );
+
+  for (const el of allElements) {
+    const tag = el.tagName.toLowerCase();
+
+    // Unwrap elements whose wrapper is unsafe but whose content should be kept
+    if (UNWRAP_TAGS.has(tag)) {
+      el.replaceWith(...el.childNodes);
+      continue;
+    }
+
+    // Remove outright dangerous elements
+    if (prohibited.has(tag)) {
+      el.remove();
+      continue;
+    }
 
-  // Strip dangerous attributes from remaining elements
-  doc.querySelectorAll('*').forEach((el) => {
-    Array.from(el.attributes).forEach((attr) => {
+    // Strip dangerous attributes
+    for (const attr of Array.from(el.attributes)) {
       // Remove all event handlers (onclick, onload, onerror, …)
       if (attr.name.startsWith('on')) {
         el.removeAttribute(attr.name);
-        return;
+        continue;
       }
       // Sanitise URL attributes
       if (URL_ATTRS.includes(attr.name)) {
         const val = attr.value.trim();
-        // Block javascript: and vbscript: protocols
         if (/^(javascript|vbscript):/i.test(val)) {
           el.removeAttribute(attr.name);
-          return;
+          continue;
         }
         // Allow data: URIs only on img[src] (base64 image uploads); block elsewhere
         if (/^data:/i.test(val) && !(attr.name === 'src' && el.tagName === 'IMG')) {
           el.removeAttribute(attr.name);
         }
       }
-
-      // Strip iframe HTML-injection vectors and limit iframe src to trusted hosts.
+      // Strip iframe HTML-injection vectors; limit src to trusted hosts
       if (el.tagName === 'IFRAME') {
         if (attr.name === 'srcdoc') {
           el.removeAttribute(attr.name);
-          return;
+          continue;
         }
-        if (attr.name === 'src') {
-          if (!isTrustedIframeSrc(attr.value)) {
-            el.removeAttribute(attr.name);
-          }
-          return;
+        if (attr.name === 'src' && !isTrustedIframeSrc(attr.value)) {
+          el.removeAttribute(attr.name);
         }
       }
-    });
-  });
+    }
 
-  // Allow only input[type="checkbox"] inside ul.an-checklist li; strip everything else.
-  // This preserves checklist state while blocking arbitrary <input> injection.
-  doc.querySelectorAll('input').forEach((el) => {
-    const inChecklist = el.closest('ul.an-checklist') !== null &&
-                        el.closest('li') !== null;
-    if (!inChecklist || el.getAttribute('type') !== 'checkbox') {
-      el.remove();
-    } else {
-      // Harden: keep only safe attributes on checklist checkboxes
-      Array.from(el.attributes).forEach((attr) => {
-        if (!['type', 'checked', 'contenteditable'].includes(attr.name)) {
-          el.removeAttribute(attr.name);
+    // Allow only input[type="checkbox"] inside ul.an-checklist li
+    if (tag === 'input') {
+      const inChecklist = el.closest('ul.an-checklist') !== null &&
+                          el.closest('li') !== null;
+      if (!inChecklist || el.getAttribute('type') !== 'checkbox') {
+        el.remove();
+      } else {
+        for (const attr of Array.from(el.attributes)) {
+          if (!['type', 'checked', 'contenteditable'].includes(attr.name)) {
+            el.removeAttribute(attr.name);
+          }
         }
-      });
+      }
     }
-  });
+  }
 
   return doc.body.innerHTML;
 }

package/src/js/editing/History.js

@@ -100,7 +100,16 @@ export class History {
       const sel = window.getSelection();
       sel.removeAllRanges();
       sel.addRange(range);
-    } catch (_) { /* detached node — ignore */ }
+    } catch (_) {
+      // Detached node — fall back to placing cursor at start of editable
+      try {
+        const fb = document.createRange();
+        fb.setStart(this.editable, 0);
+        fb.collapse(true);
+        const s = window.getSelection();
+        if (s) { s.removeAllRanges(); s.addRange(fb); }
+      } catch (_2) { /* fully give up */ }
+    }
   }
 
   _savePoint() {
@@ -138,6 +147,8 @@ export class History {
    * @returns {{ html: string, images: Object<string,string> }}
    */
   _tokenizeImages(html) {
+    // Fast-path: skip regex entirely when there are no data URIs (common case)
+    if (!html.includes('data:')) return { html, images: {} };
     const images = {};
     let index = 0;
     const tokenized = html.replace(/data:[^;]+;base64,[^"' >]*/g, (match) => {

package/src/js/editing/Style.js

@@ -236,9 +236,15 @@ export function outdent() {
 }
 
 /**
- * G.5 helper: splits a checklist at checkLi, converts it to a <p>,
- * and keeps items before/after as separate checklists.
- * @param {HTMLElement} checkLi
+ * Convert a checklist <li> into a paragraph and move any following items into a new checklist.
+ *
+ * Preserves inline markup from the converted item, strips zero-width space anchors,
+ * and replaces empty content with a non‑breaking space. If there are list items
+ * after the converted item they are moved into a new <ul class="an-checklist">
+ * inserted immediately after the original list. The original <li> is removed and
+ * the original list is removed if it becomes empty. Attempts to place the caret
+ * at the start of the newly created <p>.
+ * @param {HTMLElement} checkLi - The checklist `<li>` element to convert to a `<p>`.
  */
 function _checklistItemToP(checkLi) {
   const checkUl = checkLi.closest('.an-checklist');
@@ -248,12 +254,18 @@ function _checklistItemToP(checkLi) {
   const liIndex = allLis.indexOf(checkLi);
   const afterLis = allLis.slice(liIndex + 1);
 
-  // Build <p> from the item's text (skip the checkbox INPUT)
+  // Build <p> preserving inline formatting (bold/italic/links) from the item's content
   const p = document.createElement('p');
-  const text = Array.from(checkLi.childNodes)
-    .filter(n => !(n.nodeType === 1 && n.tagName === 'INPUT'))
-    .map(n => n.textContent).join('').replace(/\u200B/g, '').trim();
-  p.textContent = text || '\u00a0';
+  for (const child of checkLi.childNodes) {
+    if (child.nodeType === 1 && child.tagName === 'INPUT') continue;
+    p.appendChild(child.cloneNode(true));
+  }
+  // Strip ZWS anchors left over from checklist markup
+  p.innerHTML = p.innerHTML.replace(/\u200B/g, '');
+  if (!p.hasChildNodes() || !p.textContent.trim()) {
+    p.innerHTML = '';
+    p.appendChild(document.createTextNode('\u00a0'));
+  }
 
   // Move items after the current li into a new checklist
   if (afterLis.length > 0) {
@@ -296,9 +308,12 @@ export const insertOrderedList = () => execCommand('insertOrderedList');
 // ---------------------------------------------------------------------------
 
 /**
- * Applies a line-height value to every block-level element that intersects
- * the current selection.
- * @param {string} value - unitless multiplier, e.g. '1.5'
+ * Set the line-height on every block-level element that intersects the current selection.
+ *
+ * If the selection is collapsed, the nearest enclosing block element receives the style.
+ * For a non-collapsed selection, all unique block ancestors of text nodes that intersect the range are updated;
+ * if none are found, the nearest block ancestor of the range's common ancestor is updated.
+ * @param {string} value - Line-height value to apply; typically a unitless multiplier (for example, "1.5").
  */
 export function lineHeight(value) {
   const sel = window.getSelection();
@@ -324,13 +339,15 @@ export function lineHeight(value) {
 
   // For a range selection, collect all unique block ancestors of text nodes
   const blocks = new Set();
-  const iter = document.createNodeIterator(range.commonAncestorContainer, NodeFilter.SHOW_TEXT, null);
+  const iter = document.createTreeWalker(
+    range.commonAncestorContainer,
+    NodeFilter.SHOW_TEXT,
+    { acceptNode: (node) => range.intersectsNode(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP },
+  );
   let textNode;
   while ((textNode = iter.nextNode())) {
-    if (range.intersectsNode(textNode)) {
-      const block = nearestBlock(textNode);
-      if (block) blocks.add(block);
-    }
+    const block = nearestBlock(textNode);
+    if (block) blocks.add(block);
   }
   if (blocks.size === 0) {
     const block = nearestBlock(range.commonAncestorContainer);
@@ -472,9 +489,18 @@ export function isInlineCode() {
 // ---------------------------------------------------------------------------
 
 /**
- * Toggles a task-list at the cursor.
- * If inside a checklist <li>, converts it (and any other selected items) back to <p> elements.
- * Otherwise inserts a new <ul class="an-checklist"> with one item per selected line.
+ * Toggle a checklist at the current selection or caret.
+ *
+ * When the selection is inside an existing checklist `<ul class="an-checklist">`,
+ * converts the selected `<li>` items back into `<p>` paragraphs and places the caret
+ * at the start of the first converted paragraph. Otherwise creates a checklist:
+ * - If the selection is collapsed, converts the nearest block-level ancestor (or inserts
+ *   a single checklist item at the editable root) into a checklist with one item containing
+ *   that block's text and places the caret inside the new item.
+ * - If the selection is a range, converts each intersecting block element into one checklist
+ *   item (preserving textual content) and places the caret at the end of the last item.
+ *
+ * Empty or whitespace-only selections do not create a checklist.
  */
 export function toggleChecklist() {
   const sel = window.getSelection();
@@ -549,8 +575,10 @@ export function toggleChecklist() {
     if (block && BLOCK_TAGS.has(block.tagName)) {
       block.parentNode.replaceChild(ul, block);
     } else {
-      document.execCommand('insertHTML', false, ul.outerHTML);
-      return;
+      // Cursor directly in editable root — insert via Range API
+      const nativeRange = sel.getRangeAt(0);
+      nativeRange.deleteContents();
+      nativeRange.insertNode(ul);
     }
 
     // Move caret to the text node inside the new <li>

package/src/js/editing/Table.js

@@ -4,18 +4,18 @@
  */
 
 import { createElement } from '../core/dom.js';
-import { execCommand } from './Style.js';
 
 // ---------------------------------------------------------------------------
 // Table creation
 // ---------------------------------------------------------------------------
 
 /**
- * Creates a table element with the specified dimensions.
- * @param {number} cols
- * @param {number} rows
- * @param {{ headerRow?: boolean }} [opts]
- * @returns {HTMLTableElement}
+ * Build an HTML table with the given number of columns and rows, optionally including a header row.
+ * @param {number} cols - Number of columns in each row.
+ * @param {number} rows - Total number of rows to create (including header when `headerRow` is true).
+ * @param {{ headerRow?: boolean }} [opts] - Options object.
+ * @param {boolean} [opts.headerRow=false] - When true and `rows > 0`, creates a header row (`<thead>`) plus body rows for the remainder.
+ * @returns {HTMLTableElement} The constructed `<table>` element with a `<tbody>` and optional `<thead>`; each cell contains a `<br>` placeholder.
  */
 export function createTable(cols, rows, opts = {}) {
   const { headerRow = false } = opts;
@@ -25,7 +25,7 @@ export function createTable(cols, rows, opts = {}) {
     const thead = createElement('thead');
     const tr = createElement('tr');
     for (let c = 0; c < cols; c++) {
-      const th = createElement('th', {}, ['\u00a0']);
+      const th = createElement('th', {}, [document.createElement('br')]);
       tr.appendChild(th);
     }
     thead.appendChild(tr);
@@ -39,7 +39,7 @@ export function createTable(cols, rows, opts = {}) {
   for (let r = 0; r < bodyRows; r++) {
     const tr = createElement('tr');
     for (let c = 0; c < cols; c++) {
-      const td = createElement('td', {}, ['\u00a0']); // &nbsp;
+      const td = createElement('td', {}, [document.createElement('br')]);
       tr.appendChild(td);
     }
     tbody.appendChild(tr);
@@ -48,12 +48,52 @@ export function createTable(cols, rows, opts = {}) {
 }
 
 /**
- * Inserts a table at the current cursor position.
- * @param {number} cols
- * @param {number} rows
- * @param {{ headerRow?: boolean }} [opts]
+ * Insert a table at the current selection and place the caret into its first cell.
+ * @param {number} cols - Number of columns for the new table.
+ * @param {number} rows - Number of rows for the new table.
+ * @param {{ headerRow?: boolean }} [opts] - Options for table creation.
+ * @param {boolean} [opts.headerRow=false] - If true, include a header row as the first row.
  */
 export function insertTable(cols, rows, opts = {}) {
+  if (cols <= 0 || rows <= 0) return;
   const table = createTable(cols, rows, opts);
-  execCommand('insertHTML', table.outerHTML);
+
+  const sel = window.getSelection();
+  if (!sel || sel.rangeCount === 0) return;
+  const range = sel.getRangeAt(0);
+  range.deleteContents();
+
+  // Walk up to find the nearest block-level ancestor to insert after
+  const BLOCK = new Set(['P', 'DIV', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'BLOCKQUOTE', 'LI', 'PRE']);
+  let anchor = range.startContainer;
+  if (anchor.nodeType === 3) anchor = anchor.parentElement;
+  while (anchor && !BLOCK.has(anchor.tagName?.toUpperCase()) && anchor.parentElement) {
+    anchor = anchor.parentElement;
+  }
+
+  if (anchor && BLOCK.has(anchor.tagName?.toUpperCase()) && anchor.parentNode) {
+    anchor.after(table);
+    // Ensure there's a paragraph after the table for cursor landing
+    if (!table.nextElementSibling) {
+      const p = document.createElement('p');
+      p.appendChild(document.createElement('br'));
+      table.after(p);
+    }
+    // Remove the anchor block if it was empty (common case: cursor in blank paragraph)
+    if (!anchor.textContent.trim() && !anchor.querySelector('img, video, table')) {
+      anchor.remove();
+    }
+  } else {
+    range.insertNode(table);
+  }
+
+  // Place cursor in the first cell
+  const firstCell = table.querySelector('td, th');
+  if (firstCell) {
+    const nr = document.createRange();
+    nr.setStart(firstCell, 0);
+    nr.collapse(true);
+    sel.removeAllRanges();
+    sel.addRange(nr);
+  }
 }

package/src/js/editing/Typing.js

@@ -206,11 +206,11 @@ export function handleKeydown(event, editable, options = {}) {
       return true;
     }
 
-    // In a pre/code block, insert spaces
+    // In a pre/code block, insert spaces using configured tabSize
     if (para && para.nodeName.toUpperCase() === 'PRE') {
       if (event.shiftKey) return false;
       event.preventDefault();
-      execCommand('insertText', '    ');
+      execCommand('insertText', ' '.repeat(options.tabSize || 4));
       return true;
     }
 
@@ -357,6 +357,13 @@ export function handleKeydown(event, editable, options = {}) {
 
     const para = closestPara(range.sc, editable);
 
+    // Enter in a pre/code block: insert a literal newline instead of a new block
+    if (para && para.nodeName.toUpperCase() === 'PRE') {
+      event.preventDefault();
+      execCommand('insertText', '\n');
+      return true;
+    }
+
     // Pressing Enter at the end of a blockquote should exit it
     if (para && para.nodeName.toUpperCase() === 'BLOCKQUOTE') {
       const native = range.toNativeRange();

package/src/js/i18n/de.js

@@ -156,6 +156,7 @@ export const de = {
     replacePlaceholder: 'Ersetzen durch…',
     replaceAriaLabel:   'Ersetzen durch',
     replaceBtn:         'Ersetzen',
+    noResults:          'Keine Ergebnisse',
     replaceAllBtn:      'Alle ersetzen',
     close:              '×',
   },

package/src/js/i18n/en.js

@@ -159,6 +159,7 @@ export const en = {
     replaceAriaLabel:   'Replace with',
     replaceBtn:         'Replace',
     replaceAllBtn:      'Replace All',
+    noResults:          'No results',
     close:              '\u00d7',
   },
 

package/src/js/i18n/es.js

@@ -156,6 +156,7 @@ export const es = {
     replacePlaceholder: 'Reemplazar con…',
     replaceAriaLabel:   'Reemplazar con',
     replaceBtn:         'Reemplazar',
+    noResults:          'Sin resultados',
     replaceAllBtn:      'Reemplazar todo',
     close:              '×',
   },

package/src/js/i18n/fr.js

@@ -157,6 +157,7 @@ export const fr = {
     replacePlaceholder: 'Remplacer par\u2026',
     replaceAriaLabel:   'Remplacer par',
     replaceBtn:         'Remplacer',
+    noResults:          'Aucun résultat',
     replaceAllBtn:      'Tout remplacer',
     close:              '\u00d7',
   },

package/src/js/i18n/ja.js

@@ -157,6 +157,7 @@ export const ja = {
     replacePlaceholder: '置換後\u2026',
     replaceAriaLabel:   '置換後のテキスト',
     replaceBtn:         '置換',
+    noResults:          '結果なし',
     replaceAllBtn:      'すべて置換',
     close:              '\u00d7',
   },

package/src/js/i18n/ko.js

@@ -156,6 +156,7 @@ export const ko = {
     replacePlaceholder: '바꿀 내용…',
     replaceAriaLabel:   '바꿀 내용',
     replaceBtn:         '바꾸기',
+    noResults:          '결과 없음',
     replaceAllBtn:      '모두 바꾸기',
     close:              '×',
   },

package/src/js/i18n/vi.js

@@ -158,6 +158,7 @@ export const vi = {
     replaceAriaLabel:   'Thay thế bằng',
     replaceBtn:         'Thay thế',
     replaceAllBtn:      'Thay thế tất cả',
+    noResults:          'Không có kết quả',
     close:              '\u00d7',
   },
 

package/src/js/i18n/zh.js

@@ -157,6 +157,7 @@ export const zh = {
     replacePlaceholder: '替换为\u2026',
     replaceAriaLabel:   '替换为',
     replaceBtn:         '替换',
+    noResults:          '没有结果',
     replaceAllBtn:      '全部替换',
     close:              '\u00d7',
   },