autumnnote 2.0.0 → 2.2.0

package/src/js/editing/Table.js

@@ -1,105 +0,0 @@
-/**
- * Table.js - Table creation and manipulation utilities
- * Inspired by Summernote's table handling
- */
-
-import { createElement } from '../core/dom.js';
-
-// ---------------------------------------------------------------------------
-// Table creation
-// ---------------------------------------------------------------------------
-
-/**
- * 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: `headerRow` creates a `<thead>` when true.
- * @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;
-  const table = createElement('table', { class: 'an-table' });
-
-  if (headerRow && rows > 0) {
-    const thead = createElement('thead');
-    const tr = createElement('tr');
-    for (let c = 0; c < cols; c++) {
-      const th = createElement('th', {}, [document.createElement('br')]);
-      tr.appendChild(th);
-    }
-    thead.appendChild(tr);
-    table.appendChild(thead);
-  }
-
-  const bodyRows = headerRow ? Math.max(rows - 1, 1) : rows;
-  const tbody = createElement('tbody');
-  table.appendChild(tbody);
-
-  for (let r = 0; r < bodyRows; r++) {
-    const tr = createElement('tr');
-    for (let c = 0; c < cols; c++) {
-      const td = createElement('td', {}, [document.createElement('br')]);
-      tr.appendChild(td);
-    }
-    tbody.appendChild(tr);
-  }
-  return /** @type {HTMLTableElement} */ (table);
-}
-
-/**
- * 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.
- */
-export function insertTable(cols, rows, opts = {}) {
-  if (cols <= 0 || rows <= 0) return;
-  const table = createTable(cols, rows, opts);
-
-  const sel = globalThis.getSelection();
-  if (!sel || sel.rangeCount === 0) return;
-  const range = sel.getRangeAt(0);
-  try {
-    range.deleteContents();
-  } catch (_) {
-    return;
-  }
-
-  // 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 = /** @type {Element|null} */ (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 {
-    try {
-      range.insertNode(table);
-    } catch (_) {
-      return;
-    }
-  }
-
-  // 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

@@ -1,397 +0,0 @@
-/**
- * Typing.js - Keyboard typing event handling (Enter, Tab, Backspace behaviour)
- * Inspired by Summernote's Typing module
- */
-
-import { key, isKey } from '../core/key.js';
-import { closestPara, isLi } from '../core/dom.js';
-import { execCommand, outdent } from './Style.js';
-import { currentRange } from '../core/range.js';
-
-// ---------------------------------------------------------------------------
-// Module-level predicates — defined once, not re-created on every keypress.
-// Previously these were arrow functions inside handleKeydown() which fires
-// at ~120+ events/sec during normal typing.
-// ---------------------------------------------------------------------------
-const _FA_PATTERN = /\bfa-/;
-const isFAIcon = (n) => !!(n?.nodeName === 'I' && _FA_PATTERN.test(n.className || ''));
-const isZwsAnchor = (n) => !!(n?.nodeType === Node.TEXT_NODE && (n.textContent === '\u200B' || n.textContent === ''));
-
-/**
- * Extracts the content from `startContainer:startOffset` to the end of `li`.
- * Returns an empty fragment if the range is invalid (e.g. detached node).
- * @param {Range} nativeRange
- * @param {Element} li
- * @returns {DocumentFragment}
- */
-function extractAfterContent(nativeRange, li) {
-  try {
-    const r = document.createRange();
-    r.setStart(nativeRange.startContainer, nativeRange.startOffset);
-    r.setEnd(li, li.childNodes.length);
-    return r.extractContents();
-  } catch (_) {
-    void _;
-    return document.createDocumentFragment();
-  }
-}
-
-/**
- * Handles special keydown behaviour inside the editor.
- * @param {KeyboardEvent} event
- * @param {HTMLElement} editable
- * @param {object} options - editor options
- * @returns {boolean} true if the event was consumed
- */
-export function handleKeydown(event, editable, options = {}) {
-  const moveCaret = (setFn) => {
-    const sel = globalThis.getSelection();
-    if (!sel) return false;
-    const nr = document.createRange();
-    setFn(nr);
-    nr.collapse(true);
-    sel.removeAllRanges();
-    sel.addRange(nr);
-    return true;
-  };
-
-  // -------------------------------------------------------------------------
-  // Backspace key — one-press deletion of a preceding FA icon (<i> element)
-  // -------------------------------------------------------------------------
-  if (isKey(event, key.BACKSPACE)) {
-    const sel = globalThis.getSelection();
-    if (sel?.rangeCount > 0) {
-      const r = sel.getRangeAt(0);
-      if (r.collapsed && r.startContainer.nodeType === Node.TEXT_NODE) {
-        const textNode = /** @type {ChildNode} */ (r.startContainer);
-        // Case A: cursor at offset 0, preceding sibling is an FA icon
-        if (r.startOffset === 0 && isFAIcon(textNode.previousSibling)) {
-          event.preventDefault();
-          /** @type {ChildNode} */ (textNode.previousSibling).remove();
-          return true;
-        }
-
-        // Case B: cursor at offset 1 of a ZWS-only text node whose preceding
-        // sibling is an FA icon. The ZWS is the invisible caret anchor inserted
-        // by IconDialog; treat the whole Backspace as "delete icon + its anchor".
-        if (r.startOffset === 1 && textNode.textContent === '\u200B' &&
-            isFAIcon(textNode.previousSibling)) {
-          event.preventDefault();
-          const parent   = textNode.parentNode;
-          const icon     = /** @type {ChildNode} */ (textNode.previousSibling);
-          const prevNode = icon.previousSibling; // node before the icon (e.g. ZWS of prior icon)
-          icon.remove();
-          textNode.remove();
-          // Explicitly restore the cursor to the node preceding the deleted icon.
-          // Without this, the browser collapses the selection to the parent element
-          // (not a text node), causing the next Backspace to miss Cases A/B and
-          // requiring an extra keypress when two icons are adjacent.
-          const nr = document.createRange();
-          if (prevNode?.nodeType === Node.TEXT_NODE) {
-            nr.setStart(prevNode, prevNode.textContent.length);
-          } else if (prevNode) {
-            nr.setStartAfter(prevNode);
-          } else if (parent) {
-            nr.setStart(parent, 0);
-          }
-          nr.collapse(true);
-          sel.removeAllRanges();
-          sel.addRange(nr);
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  // -------------------------------------------------------------------------
-  // ArrowLeft / ArrowRight — one-press navigation across FA icon nodes
-  // -------------------------------------------------------------------------
-  if (isKey(event, key.LEFT) || isKey(event, key.RIGHT)) {
-    const sel = globalThis.getSelection();
-    if (!sel || sel.rangeCount === 0) return false;
-
-    const r = sel.getRangeAt(0);
-    if (!r.collapsed) return false;
-
-    const sc = r.startContainer;
-    const movingLeft = isKey(event, key.LEFT);
-
-    if (sc.nodeType === Node.TEXT_NODE) {
-      const textNode = sc;
-
-      if (movingLeft &&
-          r.startOffset === 1 &&
-          textNode.textContent === '\u200B' &&
-          isFAIcon(textNode.previousSibling)) {
-        event.preventDefault();
-        return moveCaret((nr) => nr.setStartBefore(textNode.previousSibling));
-      }
-
-      if (movingLeft && r.startOffset === 0 && isFAIcon(textNode.previousSibling)) {
-        event.preventDefault();
-        return moveCaret((nr) => nr.setStartBefore(textNode.previousSibling));
-      }
-
-      if (movingLeft &&
-          r.startOffset === 0 &&
-          isZwsAnchor(textNode.previousSibling) &&
-          isFAIcon(textNode.previousSibling.previousSibling)) {
-        event.preventDefault();
-        return moveCaret((nr) => nr.setStartBefore(textNode.previousSibling.previousSibling));
-      }
-
-      if (!movingLeft &&
-          r.startOffset === textNode.textContent.length &&
-          isFAIcon(textNode.nextSibling)) {
-        const icon = textNode.nextSibling;
-        const after = icon.nextSibling;
-        event.preventDefault();
-        if (after?.nodeType === Node.TEXT_NODE) {
-          const offset = ((after.textContent || '').startsWith('\u200B')) ? 1 : 0;
-          return moveCaret((nr) => nr.setStart(after, Math.min(offset, after.textContent.length)));
-        }
-        return moveCaret((nr) => nr.setStartAfter(icon));
-      }
-
-      if (!movingLeft &&
-          r.startOffset === textNode.textContent.length &&
-          isZwsAnchor(textNode.nextSibling) &&
-          isFAIcon(textNode.nextSibling.nextSibling)) {
-        const icon = textNode.nextSibling.nextSibling;
-        const after = icon.nextSibling;
-        event.preventDefault();
-        if (after?.nodeType === Node.TEXT_NODE) {
-          const offset = ((after.textContent || '').startsWith('\u200B')) ? 1 : 0;
-          return moveCaret((nr) => nr.setStart(after, Math.min(offset, after.textContent.length)));
-        }
-        return moveCaret((nr) => nr.setStartAfter(icon));
-      }
-    }
-
-    if (sc.nodeType === Node.ELEMENT_NODE) {
-      const el = sc;
-      if (movingLeft && r.startOffset > 0) {
-        const prev = el.childNodes[r.startOffset - 1];
-        if (isFAIcon(prev)) {
-          event.preventDefault();
-          return moveCaret((nr) => nr.setStartBefore(prev));
-        }
-        if (isZwsAnchor(prev) && isFAIcon(prev.previousSibling)) {
-          event.preventDefault();
-          return moveCaret((nr) => nr.setStartBefore(prev.previousSibling));
-        }
-      }
-      if (!movingLeft && r.startOffset < el.childNodes.length) {
-        const next = el.childNodes[r.startOffset];
-        if (isFAIcon(next)) {
-          const after = next.nextSibling;
-          event.preventDefault();
-          if (after?.nodeType === Node.TEXT_NODE) {
-            const offset = ((after.textContent || '').startsWith('\u200B')) ? 1 : 0;
-            return moveCaret((nr) => nr.setStart(after, Math.min(offset, after.textContent.length)));
-          }
-          return moveCaret((nr) => nr.setStartAfter(next));
-        }
-        if (isZwsAnchor(next) && isFAIcon(next.nextSibling)) {
-          const icon = next.nextSibling;
-          const after = icon.nextSibling;
-          event.preventDefault();
-          if (after?.nodeType === Node.TEXT_NODE) {
-            const offset = ((after.textContent || '').startsWith('\u200B')) ? 1 : 0;
-            return moveCaret((nr) => nr.setStart(after, Math.min(offset, after.textContent.length)));
-          }
-          return moveCaret((nr) => nr.setStartAfter(icon));
-        }
-      }
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Tab key — indent / outdent list items, or insert soft tab in code blocks
-  // -------------------------------------------------------------------------
-  if (isKey(event, key.TAB)) {
-    const range = currentRange(editable);
-    if (!range) return false;
-
-    const para = closestPara(range.sc, editable);
-    if (para && isLi(para)) {
-      event.preventDefault();
-      if (event.shiftKey) {
-        outdent();
-      } else {
-        execCommand('indent');
-      }
-      return true;
-    }
-
-    // In a pre/code block, insert spaces using configured tabSize
-    if (para?.nodeName.toUpperCase() === 'PRE') {
-      if (event.shiftKey) return false;
-      event.preventDefault();
-      execCommand('insertText', ' '.repeat(options.tabSize || 4));
-      return true;
-    }
-
-    // Default: insert &nbsp; * tabSize
-    if (options.tabSize) {
-      if (event.shiftKey) return false;
-      event.preventDefault();
-      execCommand('insertText', ' '.repeat(options.tabSize));
-      return true;
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Shift+Enter — insert <br> instead of opening a new block element
-  // -------------------------------------------------------------------------
-  if (isKey(event, key.ENTER) && event.shiftKey) {
-    event.preventDefault();
-    execCommand('insertLineBreak');
-    return true;
-  }
-
-  // -------------------------------------------------------------------------
-  // Enter key — keep consistent paragraph insertion
-  // -------------------------------------------------------------------------
-  if (isKey(event, key.ENTER) && !event.shiftKey) {
-    const range = currentRange(editable);
-    if (!range) return false;
-
-    // Hoist sc/el once so all guards below can reuse them.
-    const sc = range.sc;
-    const el = /** @type {Element|null} */ (sc.nodeType === 3 ? sc.parentElement : sc);
-
-    // Guard: if the cursor is inside a <i> FA icon element (zero text children,
-    // rendered entirely by CSS ::before), pressing Enter would split the block
-    // and leave an orphan <i> in the new paragraph — visually an "auto-created
-    // icon". Push the cursor to just after the <i> first, then fall through so
-    // the browser fires its default Enter at a safe text boundary.
-    if (el?.nodeName === 'I' && /\bfa-/.test(el.className || '')) {
-      const nr = document.createRange();
-      nr.setStartAfter(el);
-      nr.collapse(true);
-      const selI = globalThis.getSelection();
-      if (selI) { selI.removeAllRanges(); selI.addRange(nr); }
-      return false; // cursor is now outside <i> — let browser default handle Enter
-    }
-
-    // Video wrapper — Enter should create a new paragraph after the wrapper,
-    // not split the wrapper's container and produce an empty video clone.
-    const videoWrapper = el?.closest('.an-video-wrapper');
-    if (videoWrapper) {
-      event.preventDefault();
-      const p = document.createElement('p');
-      p.innerHTML = '\u00a0';
-      videoWrapper.parentNode.insertBefore(p, videoWrapper.nextSibling);
-      const nr = document.createRange();
-      nr.setStart(p, 0);
-      nr.collapse(true);
-      const sel = globalThis.getSelection();
-      sel.removeAllRanges();
-      sel.addRange(nr);
-      return true;
-    }
-
-    // Checklist — Enter creates new item; empty item exits the list
-    const checkLi = el?.closest('.an-checklist li');
-    if (checkLi) {
-      event.preventDefault();
-      const ul = checkLi.closest('.an-checklist');
-      const sel = globalThis.getSelection();
-      let nativeRange = sel.getRangeAt(0);
-
-      // Helper: get trimmed text content of a li, excluding the checkbox INPUT.
-      // Strip both \u00a0 (placeholder nbsp) and \u200B (ZWS cursor anchors).
-      const liText = (li) =>
-        Array.from(li.childNodes)
-          .filter((n) => !(n.nodeType === 1 && n.tagName === 'INPUT'))
-          .map((n) => n.textContent).join('').replace(/[\u00a0\u200B]/g, ' ').trim();
-
-      // 1. Check if the ENTIRE item is empty BEFORE any DOM mutation.
-      //    (Do NOT check only the "before-cursor" part — that check incorrectly
-      //    exits the list when cursor is at the start of a non-empty item.)
-      if (!liText(checkLi)) {
-        // Empty item — exit checklist, insert <p> after list
-        const p = document.createElement('p');
-        p.innerHTML = '\u00a0';
-        ul.parentNode.insertBefore(p, ul.nextSibling);
-        checkLi.remove();
-        if (ul.children.length === 0) ul.remove();
-        const nr = document.createRange();
-        nr.setStart(p.firstChild, 0);
-        nr.collapse(true);
-        sel.removeAllRanges();
-        sel.addRange(nr);
-        return true;
-      }
-
-      // 2. If selection is not collapsed, delete the selected content first —
-      //    mirrors browser-default Enter behaviour (delete selection, then split).
-      if (!nativeRange.collapsed) {
-        nativeRange.deleteContents();
-        // nativeRange is now collapsed at the deletion point; re-read it
-        if (sel.rangeCount === 0 || !checkLi.isConnected) return true;
-        nativeRange = sel.getRangeAt(0);
-      }
-
-      // 3. Extract everything from cursor to end of li into afterFrag.
-      //    Use startContainer/startOffset (cursor position after potential delete),
-      //    NOT endContainer/endOffset which is wrong for non-collapsed ranges.
-      const afterFrag = extractAfterContent(nativeRange, checkLi);
-
-      // 4. Build the new checklist item with the extracted "after" content.
-      const newLi = document.createElement('li');
-      const cb = document.createElement('input');
-      cb.type = 'checkbox';
-      cb.setAttribute('contenteditable', 'false');
-      newLi.appendChild(cb);
-
-      // Append extracted "after" content (if any) then insert the new item.
-      if (afterFrag.textContent.replace(/[\u00a0\u200B]/g, '').length > 0) {
-        newLi.appendChild(afterFrag);
-      }
-
-      // Always ensure a text node exists so the cursor has a text-level
-      // anchor. Use \u200B (zero-width space) instead of an empty string:
-      // Chrome does not reliably honour a Selection in an empty text node and
-      // may normalise it to element-level, placing the caret before the
-      // absolutely-positioned checkbox.  \u200B is stripped by getHTML().
-      let cursorNode = newLi.childNodes[1]; // first child after checkbox
-      if (cursorNode?.nodeType !== Node.TEXT_NODE) {
-        cursorNode = document.createTextNode('\u200B');
-        newLi.appendChild(cursorNode);
-      }
-      checkLi.after(newLi);
-
-      const nr = document.createRange();
-      nr.setStart(cursorNode, 0);
-      nr.collapse(true);
-      sel.removeAllRanges();
-      sel.addRange(nr);
-      return true;
-    }
-
-    const para = closestPara(range.sc, editable);
-
-    // Enter in a pre/code block: insert a literal newline instead of a new block
-    if (para?.nodeName.toUpperCase() === 'PRE') {
-      event.preventDefault();
-      execCommand('insertText', '\n');
-      return true;
-    }
-
-    // Pressing Enter at the end of a blockquote should exit it
-    if (para?.nodeName.toUpperCase() === 'BLOCKQUOTE') {
-      const native = range.toNativeRange();
-      native.setEnd(para, para.childNodes.length);
-      if (native.toString() === '' && range.isCollapsed()) {
-        event.preventDefault();
-        execCommand('formatBlock', '<p>');
-        return true;
-      }
-    }
-  }
-
-  return false;
-}

package/src/js/index.js

@@ -1,193 +0,0 @@
-/**
- * index.js - Public entry point for AutumnNote
- *
- * Usage (module):
- *   import AutumnNote from 'autumnnote';
- *   const editor = AutumnNote.create('#my-editor', { placeholder: 'Start typing…' });
- *
- * Usage (UMD / script tag):
- *   const editor = AutumnNote.create('#my-editor');
- */
-
-// @ts-ignore
-import '../styles/autumnnote.scss';
-import { Context, _customModules, _globalPlugins } from './Context.js';
-import { registerButton, buttons } from './module/Buttons.js';
-import { defaultOptions } from './settings.js';
-import { registerLocale } from './i18n/index.js';
-
-// Snapshot of factory defaults taken at module-load time (before any setDefaults() calls)
-const _originalDefaults = { ...defaultOptions };
-
-// Re-export for tree-shaking / module consumers
-export { Context } from './Context.js';
-export { defaultOptions } from './settings.js';
-export * from './core/dom.js';
-export * from './core/range.js';
-export * from './core/func.js';
-export * from './core/key.js';
-export * from './core/lists.js';
-export * from './core/env.js';
-export * from './core/sanitise.js';
-export * from './module/Buttons.js';
-export { locales, resolveLocale, registerLocale } from './i18n/index.js';
-
-// ---------------------------------------------------------------------------
-// Main factory
-// ---------------------------------------------------------------------------
-
-/** @type {WeakMap<Element, Context>} */
-const instances = new WeakMap();
-
-const AutumnNote = {
-  /**
-   * Creates (or returns existing) editor instance on one or more elements.
-   *
-   * @param {string|Element|NodeList|Element[]} selector
-   * @param {import('./settings.js').AsnOptions} [options]
-   * @returns {Context|Context[]} single Context or array of Contexts
-   */
-  create(selector, options = {}) {
-    const elements = resolveElements(selector);
-    const ctxs = elements.map((el) => {
-      if (instances.has(el)) return instances.get(el);
-      const ctx = new Context(/** @type {HTMLElement} */ (el), options);
-      ctx.initialize();
-      instances.set(el, ctx);
-      return ctx;
-    });
-    return ctxs.length === 1 ? ctxs[0] : ctxs;
-  },
-
-  /**
-   * Destroys the editor(s) on the given selector.
-   * @param {string|Element|NodeList|Element[]} selector
-   */
-  destroy(selector) {
-    resolveElements(selector).forEach((el) => {
-      const ctx = instances.get(el);
-      if (ctx) {
-        ctx.destroy();
-        instances.delete(el);
-      }
-    });
-  },
-
-  /**
-   * Returns the Context instance for a given element (or null).
-   * @param {string|Element} selector
-   * @returns {Context|null}
-   */
-  getInstance(selector) {
-    const el = typeof selector === 'string' ? document.querySelector(selector) : selector;
-    return el ? instances.get(el) || null : null;
-  },
-
-  /** Returns a shallow copy of the default options (read-only snapshot). */
-  get defaults() { return { ...defaultOptions }; },
-
-  /** Merges properties into the global defaults, applied to all future instances. */
-  setDefaults(overrides) { Object.assign(defaultOptions, overrides); },
-
-  /** Restores global defaults to their original factory values. */
-  resetDefaults() {
-    Object.keys(defaultOptions).forEach((k) => delete defaultOptions[k]);
-    Object.assign(defaultOptions, _originalDefaults);
-  },
-
-  /**
-   * Registers a custom module to be included in every new editor instance.
-   * @param {string} name - unique module key used for ctx.invoke() calls
-   * @param {Function} ModuleClass - class with initialize() and optional destroy()
-   */
-  registerModule(name, ModuleClass) { _customModules.set(name, ModuleClass); },
-
-  /**
-   * Installs a plugin globally — applied to every future editor instance.
-   * Plugin `buttons` are registered to the global button registry immediately
-   * so they are available when Toolbar initialises inside create().
-   * Plugin `install()` is called after all built-in modules have initialised.
-   * @param {object} plugin - { name, version?, buttons?, install?, uninstall? }
-   * @param {object} [options] - Forwarded to plugin.install(context, options)
-   * @returns {typeof AutumnNote}
-   */
-  use(plugin, options = {}) {
-    if (!plugin || typeof plugin.name !== 'string') {
-      throw new TypeError('[AutumnNote] AutumnNote.use: plugin must have a string `name` property.');
-    }
-    if (_globalPlugins.has(plugin.name)) {
-      console.warn(`[AutumnNote] Plugin "${plugin.name}" already registered globally. Skipping.`);
-      return this;
-    }
-    if (Array.isArray(plugin.buttons)) {
-      plugin.buttons.forEach((b) => registerButton(b));
-    }
-    _globalPlugins.set(plugin.name, { plugin, options });
-    return this;
-  },
-
-  /**
-   * Returns true if a plugin with the given name has been registered globally.
-   * @param {string} name
-   * @returns {boolean}
-   */
-  hasPlugin(name) { return _globalPlugins.has(name); },
-
-  /**
-   * Registers a single button definition in the global button registry.
-   * After create(), call ctx.invoke('toolbar.rebuild') to render new buttons.
-   * @param {object} btnDef - ButtonDef-compatible object with a `name` string
-   * @returns {typeof AutumnNote}
-   */
-  registerButton(btnDef) { registerButton(btnDef); return this; },
-
-  /**
-   * Registers a locale so `lang: '<code>'` can select it.
-   * Only English ships in the ESM bundle — import others from
-   * `autumnnote/i18n/<code>` and register them here.
-   * @param {string} code
-   * @param {object} locale
-   */
-  registerLocale(code, locale) { registerLocale(code, locale); return this; },
-
-  /** Registers a slash-menu command for future editor instances. */
-  registerSlashCommand(command) {
-    if (!command?.id || typeof command.run !== 'function') {
-      throw new TypeError('[AutumnNote] Slash command requires an id and run(context) function.');
-    }
-    const commands = defaultOptions.slashCommands;
-    const index = commands.findIndex((item) => item.id === command.id);
-    if (index >= 0) commands[index] = command;
-    else commands.push(command);
-    return this;
-  },
-
-  /** All pre-built button definitions — accessible in every module format including UMD/CJS. */
-  buttons,
-
-  /** Library version */
-  version: '2.0.0',
-};
-
-// ---------------------------------------------------------------------------
-// Helper
-// ---------------------------------------------------------------------------
-
-/**
- * @param {string|Element|NodeList|Element[]} selector
- * @returns {Element[]}
- */
-function resolveElements(selector) {
-  if (typeof selector === 'string') {
-    return Array.from(document.querySelectorAll(selector));
-  }
-  if (selector instanceof Element) {
-    return [selector];
-  }
-  if (selector instanceof NodeList || Array.isArray(selector)) {
-    return /** @type {Element[]} */ (Array.from(selector));
-  }
-  return [];
-}
-
-export default AutumnNote;