import { EditorEngine } from '@remyxjs/core';
import {
  registerFormattingCommands,
  registerHeadingCommands,
  registerListCommands,
  registerLinkCommands,
  registerImageCommands,
  registerTableCommands,
  registerBlockCommands,
} from '@remyxjs/core';
import '@remyxjs/core/style.css';

const element = document.querySelector('#editor');
const engine = new EditorEngine(element, { outputFormat: 'html' });

// Register the commands you need
registerFormattingCommands(engine);
registerHeadingCommands(engine);
registerListCommands(engine);
registerLinkCommands(engine);
registerImageCommands(engine);
registerTableCommands(engine);
registerBlockCommands(engine);

// Initialize
engine.init();

// Listen for changes
engine.on('content:change', () => {
  console.log(engine.getHTML());
});

// Execute commands
engine.executeCommand('bold');
engine.executeCommand('heading', 2);

// Cleanup when done
engine.destroy();

const engine = new EditorEngine(element, {
  outputFormat: 'html',       // 'html' or 'markdown'
  history: {
    maxSize: 100,             // Maximum undo states
    debounceMs: 300,          // Debounce interval for snapshots
  },
  sanitize: {
    allowedTags: { ... },     // Tag-to-attributes map (extends defaults)
    allowedStyles: [ ... ],   // Allowed CSS properties (extends defaults)
  },
  baseHeadingLevel: 1,        // Heading offset (2 renders H1 as <h2>)
  uploadHandler: async (file) => {
    // Return a URL string for the uploaded file
    const url = await myUploadService(file);
    return url;
  },
  maxFileSize: 10 * 1024 * 1024, // 10 MB (default)
});

engine.on('content:change', () => {
  saveToServer(engine.getHTML());
});

engine.on('selection:change', (formats) => {
  updateToolbarState(formats);
  // formats: { bold, italic, underline, heading, alignment, link, ... }
});

engine.on('upload:error', ({ file, error }) => {
  showNotification(`Upload failed: ${error.message}`);
});

// The return value is an unsubscribe function
const unsub = engine.on('focus', () => console.log('focused'));
unsub(); // stop listening

registerFormattingCommands(engine);

engine.executeCommand('bold'); // Toggle bold (Mod+B)
engine.executeCommand('italic'); // Toggle italic (Mod+I)
engine.executeCommand('underline'); // Toggle underline (Mod+U)
engine.executeCommand('strikethrough'); // Toggle strikethrough (Mod+Shift+X)
engine.executeCommand('subscript'); // Toggle subscript (Mod+,)
engine.executeCommand('superscript'); // Toggle superscript (Mod+.)
engine.executeCommand('removeFormat'); // Strip all inline formatting

registerHeadingCommands(engine);

engine.executeCommand('heading', 1); // Apply H1
engine.executeCommand('heading', 3); // Apply H3
engine.executeCommand('heading', 'p'); // Reset to paragraph
engine.executeCommand('h2'); // Shorthand for heading level 2
engine.executeCommand('paragraph'); // Shorthand for normal text

registerListCommands(engine);

engine.executeCommand('orderedList'); // Toggle numbered list (Mod+Shift+7)
engine.executeCommand('unorderedList'); // Toggle bullet list (Mod+Shift+8)
engine.executeCommand('taskList'); // Toggle task list with checkboxes
engine.executeCommand('indent'); // Increase indentation
engine.executeCommand('outdent'); // Decrease indentation

registerAlignmentCommands(engine);

engine.executeCommand('alignLeft');
engine.executeCommand('alignCenter');
engine.executeCommand('alignRight');
engine.executeCommand('alignJustify');

registerLinkCommands(engine);

// Insert a new link (Mod+K)
engine.executeCommand('insertLink', {
  href: 'https://example.com',
  text: 'Example', // optional — uses selection if omitted
  target: '_blank', // optional
});

// Edit an existing link
engine.executeCommand('editLink', {
  href: 'https://new-url.com',
  text: 'New text', // optional
  target: '_self', // optional
});

// Remove link, keep text
engine.executeCommand('removeLink');

registerImageCommands(engine);

// Insert image
engine.executeCommand('insertImage', {
  src: 'https://example.com/photo.jpg',
  alt: 'A photo', // optional
  width: 400, // optional
  height: 300, // optional
});

// Resize an existing image
engine.executeCommand('resizeImage', {
  element: imgElement,
  width: 200,
  height: 150,
});

// Align image
engine.executeCommand('alignImage', {
  element: imgElement,
  alignment: 'center', // 'left', 'right', 'center'
});

// Remove image
engine.executeCommand('removeImage', { element: imgElement });

registerTableCommands(engine);

// Insert a 4x3 table (first row is <thead> with <th> cells)
engine.executeCommand('insertTable', { rows: 4, cols: 3 });

// Row operations
engine.executeCommand('addRowBefore');
engine.executeCommand('addRowAfter');
engine.executeCommand('deleteRow');

// Column operations
engine.executeCommand('addColBefore');
engine.executeCommand('addColAfter');
engine.executeCommand('deleteCol');

// Toggle header row (convert first row to/from <thead>)
engine.executeCommand('toggleHeaderRow');

// Sort by column (physically reorders rows, sets data-sort-dir on <th>)
engine.executeCommand('sortTable', {
  columnIndex: 0,
  direction: 'asc',
});
engine.executeCommand('sortTable', {
  columnIndex: 0,
  direction: 'desc',
  dataType: 'numeric',
});

// Multi-column sort
engine.executeCommand('sortTable', {
  keys: [
    { columnIndex: 0, direction: 'asc' },
    { columnIndex: 1, direction: 'desc', dataType: 'numeric' },
  ],
});

// Filter rows (non-destructive, hides non-matching rows)
engine.executeCommand('filterTable', {
  columnIndex: 0,
  filterValue: 'search term',
});
engine.executeCommand('clearTableFilters');

// Cell formatting (stores raw value in data-raw-value, displays formatted)
engine.executeCommand('formatCell', { format: 'number' });
engine.executeCommand('formatCell', {
  format: 'currency',
  options: { currency: 'EUR' },
});
engine.executeCommand('formatCell', { format: 'percentage' });
engine.executeCommand('formatCell', {
  format: 'date',
  options: { dateStyle: 'long' },
});

// Formula evaluation (cells with data-formula attribute)
engine.executeCommand('evaluateFormulas');

// Merge and split
engine.executeCommand('mergeCells', { cells: [cell1, cell2] });
engine.executeCommand('splitCell');

engine.options.tableSortComparator = (
  a,
  b,
  dataType,
  columnIndex,
) => {
  // Custom comparison — return negative, zero, or positive
  return a.localeCompare(b, 'de'); // German locale sort
};

import { evaluateTableFormulas } from '@remyxjs/core';

const table = document.querySelector('table.rmx-table');
evaluateTableFormulas(table);

// Number: "1,234.50"
engine.executeCommand('formatCell', {
  format: 'number',
  options: { decimals: 2 },
});

// Currency: "$1,234.50" (or locale equivalent)
engine.executeCommand('formatCell', {
  format: 'currency',
  options: { currency: 'USD' },
});

// Euro: "1.234,50 €"
engine.executeCommand('formatCell', {
  format: 'currency',
  options: { currency: 'EUR' },
});

// Percentage: "75.0%" (raw value 0.75 × 100)
engine.executeCommand('formatCell', {
  format: 'percentage',
  options: { decimals: 1 },
});

// Date: locale-formatted date
engine.executeCommand('formatCell', {
  format: 'date',
  options: { dateStyle: 'long' },
});

registerBlockCommands(engine);

engine.executeCommand('blockquote'); // Toggle blockquote (Mod+Shift+9)
engine.executeCommand('codeBlock'); // Toggle code block (Mod+Shift+C)
engine.executeCommand('codeBlock', { language: 'javascript' }); // Code block with language
engine.executeCommand('horizontalRule'); // Insert <hr>

registerFontCommands(engine);

engine.executeCommand('fontFamily', 'Georgia');
engine.executeCommand('fontSize', '18px'); // Accepts px, pt, em, rem, %
engine.executeCommand('foreColor', '#ff0000');
engine.executeCommand('backColor', '#ffff00');

registerMediaCommands(engine);

// Embed a YouTube, Vimeo, or Dailymotion video
engine.executeCommand('embedMedia', {
  url: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
});

// Remove an embed
engine.executeCommand('removeEmbed', { element: embedElement });

registerFindReplaceCommands(engine);

// Search (Mod+F)
engine.executeCommand('find', {
  text: 'hello',
  caseSensitive: false, // optional, default false
});

engine.executeCommand('findNext');
engine.executeCommand('findPrev');

// Replace current match
engine.executeCommand('replace', { replaceText: 'world' });

// Replace all matches
engine.executeCommand('replaceAll', {
  searchText: 'hello',
  replaceText: 'world',
});

// Listen for results
engine.on('find:results', ({ total, current }) => {
  console.log(`Match ${current + 1} of ${total}`);
});

registerSourceModeCommands(engine);

// Toggle HTML source view (Mod+Shift+U)
engine.executeCommand('sourceMode');

engine.on('mode:change', ({ sourceMode }) => {
  console.log('Source mode:', sourceMode);
});

registerFullscreenCommands(engine);

// Toggle fullscreen (Mod+Shift+F)
engine.executeCommand('fullscreen');

engine.on('fullscreen:toggle', ({ fullscreen }) => {
  console.log('Fullscreen:', fullscreen);
});

registerDistractionFreeCommands(engine);

// Toggle distraction-free mode (Mod+Shift+D)
engine.executeCommand('distractionFree');

registerSplitViewCommands(engine);

// Toggle split view (Mod+Shift+V)
engine.executeCommand('toggleSplitView');

registerColorPresetCommands(engine);

// Save a named color preset (persisted in localStorage)
engine.executeCommand('saveColorPreset', {
  name: 'Brand',
  colors: ['#e11d48', '#3b82f6', '#22c55e'],
});

// Load all saved presets
const presets = engine.executeCommand('loadColorPresets');

// Delete a preset
engine.executeCommand('deleteColorPreset', 'Brand');

// Line height (applied as inline style to selected text)
engine.executeCommand('lineHeight', '1.8');

// Letter spacing
engine.executeCommand('letterSpacing', '0.05em');

// Paragraph spacing (margin-bottom on block elements)
engine.executeCommand('paragraphSpacing', '1.5em');

registerMarkdownToggleCommands(engine);

// Toggle between rich-text and markdown editing
engine.executeCommand('toggleMarkdown');

engine.on('mode:change:markdown', ({ markdownMode }) => {
  console.log('Markdown mode:', markdownMode);
});

registerAttachmentCommands(engine);

engine.executeCommand('insertAttachment', {
  url: 'https://example.com/report.pdf',
  filename: 'report.pdf',
  filesize: '2.4 MB', // optional, displayed in UI
});

engine.executeCommand('removeAttachment', {
  element: attachmentElement,
});

registerImportDocumentCommands(engine);

// Opens a native file picker for supported formats
engine.executeCommand('importDocument');

import { SLASH_COMMAND_ITEMS, filterSlashItems } from '@remyxjs/core';

// Default catalog of ~30 command items across 6 categories:
// Text, Lists, Media, Layout, Insert, Advanced
// Insert category includes plugin commands: Callout, Math Equation,
// Table of Contents, Bookmark, Merge Tag, Comment
console.log(SLASH_COMMAND_ITEMS);

// Filter items by query (fuzzy substring match on label, description, keywords)
const matches = filterSlashItems(SLASH_COMMAND_ITEMS, 'head');
// → [{ id: 'heading1', label: 'Heading 1', ... }, { id: 'heading2', ... }, ...]

import {
  getRecentCommands,
  recordRecentCommand,
  clearRecentCommands,
} from '@remyxjs/core';

// Commands are recorded automatically when executed via the palette.
// You can also record manually:
recordRecentCommand('heading1');

// Read the recent list (most recent first, max 5)
getRecentCommands(); // → ['heading1']

// Clear the history
clearRecentCommands();

// filterSlashItems pins recent items by default (disable with { pinRecent: false })
filterSlashItems(SLASH_COMMAND_ITEMS, ''); // recent items at top
filterSlashItems(SLASH_COMMAND_ITEMS, '', { pinRecent: false }); // no pinning

import {
  registerCommandItems,
  unregisterCommandItem,
  getCustomCommandItems,
} from '@remyxjs/core';

// Register a single item
registerCommandItems({
  id: 'insertSignature',
  label: 'Insert Signature',
  description: 'Add your email signature',
  icon: '✍️',
  keywords: ['signature', 'sign', 'email'],
  category: 'Custom',
  action: (engine) =>
    engine.executeCommand('insertHTML', '<p>— John Doe</p>'),
});

// Register multiple items at once
registerCommandItems([
  {
    id: 'draft',
    label: 'Save Draft',
    description: 'Save as draft',
    icon: '💾',
    keywords: ['save', 'draft'],
    category: 'Custom',
    action: (engine) => saveDraft(engine.getHTML()),
  },
  {
    id: 'publish',
    label: 'Publish',
    description: 'Publish document',
    icon: '🚀',
    keywords: ['publish', 'post'],
    category: 'Custom',
    action: (engine) => publish(engine.getHTML()),
  },
]);

// Re-registering the same id replaces the previous item
registerCommandItems({
  id: 'insertSignature',
  label: 'Insert Sig (updated)' /* ... */,
});

// Remove a custom item
unregisterCommandItem('insertSignature');

// Get all registered custom items
getCustomCommandItems(); // → [{ id: 'draft', ... }, { id: 'publish', ... }]

import {
  LocalStorageProvider,
  SessionStorageProvider,
  FileSystemProvider,
  CloudProvider,
  CustomProvider,
  createStorageProvider,
} from '@remyxjs/core';

const local = createStorageProvider(); // LocalStorageProvider
const session = createStorageProvider('sessionStorage'); // SessionStorageProvider
const cloud = createStorageProvider({
  // CloudProvider
  endpoint: 'https://api.example.com/autosave',
  headers: { Authorization: 'Bearer token123' },
});
const fs = createStorageProvider({
  // FileSystemProvider
  writeFn: async (key, data) => writeFile(`/saves/${key}.json`, data),
  readFn: async (key) => readFile(`/saves/${key}.json`),
  deleteFn: async (key) => unlink(`/saves/${key}.json`),
});

const s3Provider = new CloudProvider({
  endpoint: 'https://my-bucket.s3.amazonaws.com',
  buildUrl: (key) => getPresignedUploadUrl(key), // S3 presigned URL
  buildLoadUrl: (key) => getPresignedDownloadUrl(key),
  method: 'PUT',
  headers: { 'Content-Type': 'application/json' },
  fetchFn: fetch, // optional custom fetch
});

import { AutosaveManager } from '@remyxjs/core';

const manager = new AutosaveManager(engine, {
  provider: 'localStorage', // or any provider config
  key: 'doc-123', // storage key (default: 'rmx-default')
  interval: 30000, // periodic save interval in ms (default: 30s)
  debounce: 2000, // debounce delay after content change (default: 2s)
  enabled: true, // toggle on/off (default: true)
});

manager.init(); // start listening to content:change

await manager.save(); // force an immediate save
await manager.checkRecovery(engine.getHTML()); // check for recoverable content
await manager.clearRecovery(); // clear stored recovery data

manager.destroy(); // cleanup timers, listeners, final save

engine.eventBus.on('autosave:saving', () => {
  console.log('Saving...');
});

engine.eventBus.on('autosave:saved', ({ timestamp }) => {
  console.log(`Saved at ${new Date(timestamp).toLocaleTimeString()}`);
});

engine.eventBus.on('autosave:error', ({ error }) => {
  console.error('Autosave failed:', error.message);
});

engine.eventBus.on(
  'autosave:recovered',
  ({ recoveredContent, timestamp }) => {
    if (confirm('Unsaved changes found. Restore?')) {
      engine.setHTML(recoveredContent);
    }
  },
);

import { createPlugin } from '@remyxjs/core';

const HighlightPlugin = createPlugin({
  name: 'highlight',

  init(api) {
    // api is a restricted PluginAPI (see below)
    api.on('selection:change', (formats) => {
      // React to selection changes
    });
  },

  destroy(api) {
    // Cleanup (event listeners registered via api.on are auto-cleaned)
  },

  // Optional: add commands
  commands: [
    {
      name: 'highlight',
      execute(engine) {
        document.execCommand('hiliteColor', false, 'yellow');
      },
      isActive(engine) {
        return (
          engine.selection.getActiveFormats().backColor === 'yellow'
        );
      },
      shortcut: 'mod+shift+h',
    },
  ],

  // Optional: add toolbar buttons
  toolbarItems: [
    {
      name: 'highlight',
      command: 'highlight',
      icon: '🖍',
      tooltip: 'Highlight',
      group: 'formatting',
    },
  ],

  // Optional: add status bar items
  statusBarItems: [
    {
      name: 'highlight-status',
      render: (engine) =>
        engine.selection.getActiveFormats().backColor || 'none',
    },
  ],

  // Optional: add context menu items
  contextMenuItems: [
    {
      name: 'highlight-menu',
      label: 'Highlight selection',
      command: 'highlight',
    },
  ],
});

// Register the plugin
engine.plugins.register(HighlightPlugin);

const AdvancedPlugin = createPlugin({
  name: 'advanced',
  requiresFullAccess: true,
  init(engine) {
    // Full EditorEngine instance — use with care
    engine.element.addEventListener('dblclick', handleDblClick);
  },
  destroy(engine) {
    engine.element.removeEventListener('dblclick', handleDblClick);
  },
});

const AnalyticsPlugin = createPlugin({
  name: 'analytics',
  onContentChange(api) {
    // Called on every content:change event
    trackEvent('content_edit', { length: api.getText().length });
  },
  onSelectionChange(api) {
    // Called on every selectionchange event
    const formats = api.getActiveFormats();
    updateToolbarState(formats);
  },
});

const BasePlugin = createPlugin({
  name: 'base',
  init() {
    /* ... */
  },
});

const ExtensionPlugin = createPlugin({
  name: 'extension',
  dependencies: ['base'], // initialized after 'base'
  init(api) {
    /* can safely use base's commands */
  },
});

const ThemePlugin = createPlugin({
  name: 'custom-theme',
  settingsSchema: [
    {
      key: 'fontSize',
      type: 'number',
      label: 'Font Size',
      defaultValue: 16,
      validate: (v) => v >= 8 && v <= 72,
    },
    {
      key: 'fontFamily',
      type: 'string',
      label: 'Font Family',
      defaultValue: 'sans-serif',
    },
    {
      key: 'mode',
      type: 'select',
      label: 'Mode',
      defaultValue: 'light',
      options: [
        { label: 'Light', value: 'light' },
        { label: 'Dark', value: 'dark' },
      ],
    },
  ],
  defaultSettings: {
    fontSize: 16,
    fontFamily: 'sans-serif',
    mode: 'light',
  },
  init(api) {
    const size = api.getSetting('fontSize');
    api.element.style.fontSize = `${size}px`;
  },
});

// Settings are accessible from outside the plugin:
engine.plugins.getPluginSetting('custom-theme', 'fontSize'); // 16
engine.plugins.setPluginSetting('custom-theme', 'fontSize', 18); // validates + emits event
engine.plugins.getPluginSettings('custom-theme'); // { fontSize: 18, fontFamily: 'sans-serif', mode: 'light' }

import {
  registerPluginInRegistry,
  searchPluginRegistry,
  listRegisteredPlugins,
} from '@remyxjs/core';

// Register a plugin for discovery
registerPluginInRegistry({
  name: 'math-equations',
  version: '1.2.0',
  description: 'LaTeX/KaTeX math rendering',
  author: 'Community',
  tags: ['math', 'latex', 'katex', 'equations'],
  factory: () => MathPlugin(),
});

// Search the registry
searchPluginRegistry('math'); // → [{ name: 'math-equations', ... }]
searchPluginRegistry('latex'); // → [{ name: 'math-equations', ... }] (matches tags)
listRegisteredPlugins(); // → all registered entries

// Install from registry
const entry = searchPluginRegistry('math')[0];
engine.plugins.register(entry.factory());

const MyPlugin = createPlugin({
  name: 'my-plugin',
  version: '2.1.0',
  description: 'Adds custom formatting options',
  author: 'Your Name',
  // ... rest of plugin definition
});

import { WordCountPlugin } from '@remyxjs/core';
engine.plugins.register(WordCountPlugin);
engine.on('wordcount:update', ({ wordCount, charCount }) => {
  document.querySelector('#count').textContent = `${wordCount} words`;
});

import { AutolinkPlugin } from '@remyxjs/core';
engine.plugins.register(AutolinkPlugin);

import { PlaceholderPlugin } from '@remyxjs/core';
engine.plugins.register(PlaceholderPlugin('Start writing...'));

import {
  SyntaxHighlightPlugin,
  SUPPORTED_LANGUAGES,
  detectLanguage,
  tokenize,
  registerLanguage,
  unregisterLanguage,
  runRules,
} from '@remyxjs/core';

// Register the plugin
engine.plugins.register(SyntaxHighlightPlugin());

// Set language on the focused code block
engine.executeCommand('setCodeLanguage', { language: 'python' });

// Get language of the focused code block
const lang = engine.executeCommand('getCodeLanguage'); // 'python' or null

// Toggle line numbers on the focused code block
engine.executeCommand('toggleLineNumbers');

// Available languages (for building UI dropdowns)
console.log(SUPPORTED_LANGUAGES);
// [{ id: 'javascript', label: 'JavaScript' }, { id: 'python', label: 'Python' }, ...]

// Auto-detect language from code content
const detected = detectLanguage('def hello():\n    print("hi")');
// 'python'

// Tokenize code programmatically
const tokens = tokenize('const x = 42', 'javascript');
// [{ type: 'keyword', value: 'const' }, { type: 'plain', value: ' x ' }, ...]

engine.executeCommand('toggleLineNumbers'); // Toggle on the focused code block

import {
  registerLanguage,
  unregisterLanguage,
  runRules,
} from '@remyxjs/core';

// Define tokenizer rules (same format used by all built-in tokenizers)
const RUBY_RULES = [
  [/#[^\n]*/g, 'rmx-syn-comment'],
  [/"(?:[^"\\]|\\.)*"/g, 'rmx-syn-string'],
  [/'(?:[^'\\]|\\.)*'/g, 'rmx-syn-string'],
  [
    /\b(?:def|end|class|module|if|else|elsif|unless|do|while|for|return|yield|begin|rescue|ensure)\b/g,
    'rmx-syn-keyword',
  ],
  [
    /\b(?:puts|print|require|include|attr_accessor|attr_reader)\b/g,
    'rmx-syn-builtin',
  ],
  [/:\w+/g, 'rmx-syn-entity'],
  [/\b\d[\d_.]*\b/g, 'rmx-syn-number'],
];

// Register with the built-in rule engine
registerLanguage(
  'ruby',
  'Ruby',
  (code) => runRules(code, RUBY_RULES),
  ['rb'],
);

// Now works everywhere
tokenize('puts "hello"', 'ruby'); // tokenize API
tokenize('puts "hello"', 'rb'); // alias works too
engine.executeCommand('setCodeLanguage', { language: 'ruby' }); // in editor

// Remove later if needed
unregisterLanguage('ruby', ['rb']);

import { TablePlugin, evaluateTableFormulas } from '@remyxjs/core';

// Register the plugin
engine.plugins.register(TablePlugin());

// The plugin automatically:
// - Attaches resize handles to table column/row borders
// - Makes <th> cells clickable for sorting (Shift+click for multi-sort)
// - Injects filter buttons into header cells
// - Evaluates formulas on cell blur (cells starting with '=')
// - Re-evaluates all formulas on content change (debounced)

// Programmatically evaluate all formulas in a table
evaluateTableFormulas(tableElement);

import { CommentsPlugin, parseMentions } from '@remyxjs/core';

// Register the plugin
engine.plugins.register(
  CommentsPlugin({
    onComment: (thread) => saveToServer(thread),
    onResolve: ({ thread, resolved }) => updateServer(thread),
    onDelete: (thread) => deleteFromServer(thread),
    onReply: ({ thread, reply }) => saveReply(thread.id, reply),
    mentionUsers: ['alice', 'bob', 'charlie'],
    commentOnly: false, // true = read-only editor with comment support
  }),
);

// The plugin exposes engine._comments API:
engine._comments.addComment({
  author: 'Alice',
  body: 'This needs clarification @bob',
});
engine._comments.resolveComment(threadId, true);
engine._comments.replyToComment(threadId, {
  author: 'Bob',
  body: 'Fixed!',
});
engine._comments.deleteComment(threadId);
engine._comments.navigateToComment(threadId); // scroll to + select
engine._comments.getAllThreads(); // all threads (newest first)
engine._comments.getUnresolvedThreads();
engine._comments.getResolvedThreads();
engine._comments.exportThreads(); // JSON-serializable array
engine._comments.importThreads(data); // load from server

// Parse @mentions from text
parseMentions('Hello @alice and @bob'); // → ['alice', 'bob']

import {
  CalloutPlugin,
  registerCalloutType,
  getCalloutTypes,
  parseGFMAlert,
} from '@remyxjs/core';

// Register the plugin
engine.plugins.register(CalloutPlugin());

// Insert a callout at the cursor
engine.executeCommand('insertCallout', { type: 'warning' });
engine.executeCommand('insertCallout', {
  type: 'tip',
  collapsible: true,
  title: 'Pro tip',
});
engine.executeCommand('insertCallout', {
  type: 'info',
  content: '<p>Custom HTML content</p>',
});

// Change type of the focused callout
engine.executeCommand('changeCalloutType', 'error');

// Toggle collapse on the focused callout
engine.executeCommand('toggleCalloutCollapse');

// Remove a callout (unwrap its content back into the editor)
engine.executeCommand('removeCallout');

// Register a custom callout type
registerCalloutType({
  type: 'security',
  label: 'Security',
  icon: '🔒',
  color: '#dc2626',
});

// List all types
getCalloutTypes(); // → [{ type: 'info', ... }, { type: 'warning', ... }, ..., { type: 'security', ... }]

// GFM alert parsing (auto-converts blockquotes like "> [!NOTE]\nText")
parseGFMAlert('[!WARNING]\nBe careful'); // → { type: 'warning', body: 'Be careful' }

import { LinkPlugin, detectLinks, slugify } from '@remyxjs/core';

engine.plugins.register(
  LinkPlugin({
    onLinkClick: ({ href, text, timestamp }) => trackClick(href),
    onUnfurl: async (url) => {
      const res = await fetch(
        `/api/unfurl?url=${encodeURIComponent(url)}`,
      );
      return res.json(); // { title, description, image }
    },
    validateLink: async (url) => {
      const res = await fetch(url, { method: 'HEAD' });
      return res.ok;
    },
    onBrokenLink: (url, el) => console.warn('Broken:', url),
    autoLink: true, // auto-convert URLs/emails/phones on Space/Enter
    showPreviews: true, // hover tooltips on links
    scanInterval: 60000, // broken link scan interval (ms)
  }),
);

// Bookmark anchors for intra-document linking
engine.executeCommand('insertBookmark', {
  name: 'Introduction',
  id: 'intro',
});
engine.executeCommand('linkToBookmark', 'intro'); // link selected text to #intro
engine.executeCommand('getBookmarks'); // → [{ id, name, element }]
engine.executeCommand('scanBrokenLinks'); // manual scan

// Utility functions
detectLinks('Visit https://example.com or email alice@test.com');
// → [{ type: 'url', value: '...', index: 6 }, { type: 'email', value: '...', index: 36 }]
slugify('Section #1: Overview!'); // → 'section-1-overview'

import {
  TemplatePlugin,
  renderTemplate,
  extractTags,
  getTemplateLibrary,
} from '@remyxjs/core';

engine.plugins.register(TemplatePlugin());

// Insert a merge tag chip at the cursor
engine.executeCommand('insertMergeTag', 'recipient_name');

// Load a pre-built template
engine.executeCommand('loadTemplate', 'email');

// Preview with sample data (read-only mode)
engine.executeCommand('previewTemplate', {
  recipient_name: 'Alice',
  body: 'Welcome!',
});
engine.executeCommand('exitPreview');

// Export as JSON
const exported = engine.executeCommand('exportTemplate');
// → { html: '...{{recipient_name}}...', tags: ['recipient_name', 'body'], sampleData: {...} }

// Render template string with data
renderTemplate('Hello {{name}}!', { name: 'World' }); // → 'Hello World!'
renderTemplate('{{#if show}}visible{{/if}}', { show: true }); // → 'visible'
renderTemplate('{{#each items}}{{name}} {{/each}}', {
  items: [{ name: 'A' }, { name: 'B' }],
}); // → 'A B '

import { KeyboardPlugin, getHeadings } from '@remyxjs/core';

// Vim mode
engine.plugins.register(KeyboardPlugin({ mode: 'vim' }));

// Emacs mode
engine.plugins.register(KeyboardPlugin({ mode: 'emacs' }));

// Default with auto-pair and custom bindings
engine.plugins.register(
  KeyboardPlugin({
    autoPair: true,
    keyBindings: { 'ctrl+shift+l': 'insertLink' },
  }),
);

// Multi-cursor: Cmd+D selects next occurrence
// Jump-to-heading: Cmd+Shift+G
// Get all headings: engine.executeCommand('getHeadings')

import { DragDropPlugin } from '@remyxjs/core';

engine.plugins.register(
  DragDropPlugin({
    onDrop: (event, data) => console.log('Dropped:', data.type),
    onFileDrop: (files) => uploadFiles(files),
    allowExternalDrop: true,
    showDropZone: true,
    enableReorder: true,
  }),
);

// Keyboard shortcuts for block reorder
engine.executeCommand('moveBlockUp'); // Cmd+Shift+ArrowUp
engine.executeCommand('moveBlockDown'); // Cmd+Shift+ArrowDown

import {
  MathPlugin,
  getSymbolPalette,
  parseMathExpressions,
  latexToMathML,
} from '@remyxjs/core';

engine.plugins.register(
  MathPlugin({
    renderMath: (latex, displayMode) =>
      katex.renderToString(latex, { displayMode }), // plug in KaTeX
  }),
);

// Insert inline math
engine.executeCommand('insertMath', {
  latex: 'E = mc^2',
  displayMode: false,
});

// Insert block equation (auto-numbered)
engine.executeCommand('insertMath', {
  latex: '\\sum_{i=1}^{n} x_i',
  displayMode: true,
});

// Symbol palette for building UIs
getSymbolPalette(); // → [{ category: 'Greek', symbols: [{ label: 'α', latex: '\\alpha' }, ...] }, ...]

// Parse math from text
parseMathExpressions('Inline $x^2$ and block $$y^2$$');
// → [{ type: 'block', src: 'y^2', ... }, { type: 'inline', src: 'x^2', ... }]

// Convert to MathML
latexToMathML('\\frac{a}{b}'); // → '<math ...><mfrac>...</mfrac></math>'

import {
  TocPlugin,
  buildOutline,
  flattenOutline,
  renderTocHTML,
  validateHeadingHierarchy,
} from '@remyxjs/core';

engine.plugins.register(
  TocPlugin({
    numbering: true,
    onOutlineChange: (outline) => updateSidebar(outline),
  }),
);

// Insert a rendered TOC into the document
engine.executeCommand('insertToc');

// Get the outline programmatically
engine.executeCommand('getOutline'); // → [{ id, text, level, number, children: [...] }]

// Scroll to a heading
engine.executeCommand('scrollToHeading', 'chapter-1');

// Validate heading hierarchy (detect H1→H3 skips)
engine.executeCommand('validateHeadings');
// → [{ message: 'Heading level skipped: H1 → H3', element }]

import {
  AnalyticsPlugin,
  analyzeContent,
  keywordDensity,
  seoAnalysis,
} from '@remyxjs/core';

engine.plugins.register(
  AnalyticsPlugin({
    wordsPerMinute: 200,
    targetWordCount: 1000,
    maxSentenceLength: 30,
    onAnalytics: (stats) => updateDashboard(stats),
  }),
);

// Toggle analytics panel visibility (emits 'analytics:toggle' event)
engine.executeCommand('toggleAnalytics');
// Available in toolbar, View menu, and command palette

// Get analytics
engine.executeCommand('getAnalytics');
// → { wordCount, charCount, sentenceCount, paragraphCount,
//     readability: { fleschKincaid, fleschReadingEase, gunningFog, colemanLiau, vocabularyLevel },
//     readingTime: { minutes, seconds, wordsPerMinute },
//     warnings: { longSentences, longParagraphs },
//     goalProgress: { target, current, percentage } }

// SEO analysis
engine.executeCommand('getSeoAnalysis', 'react');
// → { wordCount, headingCount, h1Count, keywordInfo: { count, density, positions }, hints: [...] }

// Keyword density
engine.executeCommand('getKeywordDensity', 'editor');
// → { count: 5, density: 2.3, positions: [12, 45, 78, 102, 150] }

import {
  SpellcheckPlugin,
  analyzeGrammar,
  STYLE_PRESETS,
} from '@remyxjs/core';

engine.plugins.register(
  SpellcheckPlugin({
    language: 'en-US', // BCP 47 language tag
    enabled: true, // enable on init
    grammarRules: true, // enable built-in grammar checking
    stylePreset: 'formal', // 'formal'|'casual'|'technical'|'academic'
    customService: {
      // optional external service
      check: async (text) => [...suggestions],
    },
    dictionary: ['Remyx', 'WYSIWYG'], // custom words to ignore
    persistent: true, // persist dictionary in localStorage
    onError: (errors) => {},
    onCorrection: ({ original, replacement }) => {},
  }),
);

// Toggle spellcheck on/off
engine.executeCommand('toggleSpellcheck');

// Run grammar check
engine.executeCommand('checkGrammar');

// Add word to dictionary
engine.executeCommand('addToDictionary', 'Remyx');

// Ignore a word for this session
engine.executeCommand('ignoreWord', 'colour');

// Change writing style preset
engine.executeCommand('setWritingStyle', 'casual');

// Get spellcheck stats
engine.executeCommand('getSpellcheckStats');
// → { total, grammar, style, byRule, enabled, stylePreset, language, dictionarySize, ignoredCount }

// Style presets control which rules fire:
// formal:    passive voice + wordiness + cliches + punctuation (all rules)
// casual:    cliches + punctuation only (relaxed grammar)
// technical: passive voice + punctuation (jargon OK, skip cliches)
// academic:  passive voice + wordiness + punctuation (citation-aware)

import { CollaborationPlugin } from '@remyxjs/core';

engine.plugins.register(
  CollaborationPlugin({
    serverUrl: 'wss://signal.example.com',
    roomId: 'my-document-123',
    userName: 'Alice',
    userColor: '#6366f1',
    autoConnect: true, // connect on init (default: true)
    transport: 'websocket', // 'websocket' | 'webrtc' | custom transport
    offlineQueue: true, // queue changes while disconnected (default: true)
    awarenessTimeout: 30000, // ms before marking a peer as inactive
    onPeerJoined: (peer) => console.log(`${peer.name} joined`),
    onPeerLeft: (peer) => console.log(`${peer.name} left`),
    onSync: () => console.log('Document synced'),
    onError: (err) => console.error('Collaboration error:', err),
  }),
);

// Connect / disconnect manually (when autoConnect is false)
engine.executeCommand('collaborationConnect', {
  serverUrl: 'wss://signal.example.com',
  roomId: 'room-1',
  userName: 'Bob',
});
engine.executeCommand('collaborationDisconnect');

// Query state
engine.executeCommand('collaborationGetStatus');
// → 'connected' | 'disconnected' | 'connecting' | 'error'

engine.executeCommand('collaborationGetPeers');
// → [{ id, name, color, cursor, isActive }]

const myTransport = {
  connect(roomId, handlers) {
    // handlers.onMessage(data) — call when receiving data
    // handlers.onConnect() — call when connected
    // handlers.onDisconnect(reason) — call when disconnected
    // Return a connection object with send(data) and close() methods
    return {
      send(data) {
        /* ... */
      },
      close() {
        /* ... */
      },
    };
  },
};

engine.plugins.register(
  CollaborationPlugin({
    transport: myTransport,
    roomId: 'room-1',
    userName: 'Charlie',
  }),
);

const sel = engine.selection;

// Read selection state
sel.isCollapsed(); // true if cursor (no range selected)
sel.getSelectedText(); // selected plain text
sel.getSelectedHTML(); // selected HTML fragment
sel.getBoundingRect(); // DOMRect for positioning floating UI

// Inspect formatting at cursor
const formats = sel.getActiveFormats();
// {
//   bold: true, italic: false, underline: false,
//   strikethrough: false, subscript: false, superscript: false,
//   heading: 'h2',
//   alignment: 'left',
//   orderedList: false, unorderedList: true,
//   blockquote: false, codeBlock: false,
//   link: { href: 'https://...', text: '...', target: '_blank' },
//   fontFamily: 'Georgia', fontSize: '16px',
//   foreColor: '#333', backColor: null,
// }

// Navigate the DOM
sel.getParentElement(); // nearest element containing cursor
sel.getParentBlock(); // nearest block element (div, p, li, etc.)
sel.getClosestElement('a'); // find ancestor by tag name

// Manipulate content at cursor
sel.insertHTML('<strong>injected</strong>');
sel.insertNode(document.createElement('hr'));
sel.wrapWith('mark', { class: 'highlight' });
sel.unwrap('mark');

// Save and restore position (survives DOM mutations)
const bookmark = sel.save();
// ... modify DOM ...
sel.restore(bookmark);

// Collapse cursor
sel.collapse(); // collapse to start
sel.collapse(true); // collapse to end

// BiDi-aware caret movement
sel.getBlockDirection(); // 'ltr' or 'rtl' from parent block's dir attribute
sel.isAtBiDiBoundary(); // true if caret sits between LTR and RTL characters
sel.moveVisual('left'); // move caret one character visually left (direction-aware)
sel.moveVisual('right', true); // Shift+Right: extend selection visually right
sel.moveVisual('left', false, 'word'); // move one word visually left
sel.moveVisual('right', false, 'lineboundary'); // move to visual line end

engine.history.undo(); // Undo last change
engine.history.redo(); // Redo
engine.history.canUndo(); // true if undo stack is not empty
engine.history.canRedo(); // true if redo stack is not empty
engine.history.snapshot(); // Force an immediate snapshot
engine.history.clear(); // Clear all history

// Events
engine.on('history:undo', () => updateUndoButton());
engine.on('history:redo', () => updateRedoButton());

new EditorEngine(element, {
  history: {
    maxSize: 200, // Keep up to 200 undo states (default: 100)
    debounceMs: 500, // Wait 500ms of inactivity before snapshotting (default: 300)
  },
});

// Register custom shortcuts
engine.keyboard.register('mod+shift+h', 'highlight');
engine.keyboard.unregister('mod+shift+h');

// Look up shortcuts
engine.keyboard.getShortcutForCommand('bold'); // 'mod+b'
engine.keyboard.getShortcutLabel('mod+b'); // '⌘B' on Mac, 'Ctrl+B' on Windows

// Default behavior — blocks dangerous content automatically
engine.getHTML(); // always sanitized

// Customize allowed tags, styles, and iframe domains via engine options
new EditorEngine(element, {
  sanitize: {
    allowedTags: {
      // tag name → array of allowed attributes
      div: ['class', 'id', 'style'],
      span: ['class', 'style'],
      a: ['href', 'target', 'rel', 'class'],
      img: ['src', 'alt', 'width', 'height', 'class'],
      mark: ['class'],
      // ... see schema.js for full defaults
    },
    allowedStyles: [
      'color',
      'background-color',
      'font-size',
      'font-family',
      'text-align',
      'text-decoration',
      'font-weight',
      'font-style',
      'margin',
      'padding',
      'border',
      'width',
      'height',
      // ... see schema.js for full defaults
    ],
    // Restrict which domains can be embedded via iframe
    iframeAllowedDomains: [
      'www.youtube.com',
      'youtube.com',
      'www.youtube-nocookie.com',
      'player.vimeo.com',
      'www.dailymotion.com',
      // Add your own domains here
    ],
  },
});

import {
  escapeHTML,
  escapeHTMLAttr,
  insertPlainText,
} from '@remyxjs/core';

// Escape HTML entities for safe insertion
escapeHTML('<script>alert("xss")</script>');
// '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;'

// Escape for use in HTML attributes (also escapes quotes)
escapeHTMLAttr('value with "quotes" & <brackets>');
// 'value with &quot;quotes&quot; &amp; &lt;brackets&gt;'

// Insert plain text into the editor (handles paragraphs and line breaks)
insertPlainText(engine, 'Line 1\n\nLine 2\nLine 3');
// Inserts: <p>Line 1</p><p>Line 2<br>Line 3</p>

import { htmlToMarkdown, markdownToHtml } from '@remyxjs/core';

const md = htmlToMarkdown('<h1>Hello</h1><p>World</p>');
// # Hello\n\nWorld

const html = markdownToHtml('# Hello\n\nWorld');
// <h1>Hello</h1><p>World</p>

import {
  convertDocument,
  isImportableFile,
  getSupportedExtensions,
} from '@remyxjs/core';

// Check if a file can be imported
if (isImportableFile(file)) {
  const html = await convertDocument(file);
  engine.setHTML(html);
}

// Supported extensions string (for file input accept attribute)
const accept = getSupportedExtensions();
// '.pdf,.docx,.md,.html,.htm,.txt,.csv,.tsv,.rtf'

import {
  exportAsMarkdown,
  exportAsPDF,
  exportAsDocx,
} from '@remyxjs/core';

// Export as Markdown file download
exportAsMarkdown(engine.getHTML(), 'my-document');

// Export as PDF (opens print dialog)
exportAsPDF(engine.getHTML(), 'My Document');

// Export as DOCX file download
exportAsDocx(engine.getHTML(), 'my-document');

import { cleanPastedHTML, looksLikeMarkdown } from '@remyxjs/core';

// Remove source-specific markup (Word, Google Docs, LibreOffice, Apple Pages)
const cleaned = cleanPastedHTML(rawHTML);

// Detect if pasted text is markdown
if (looksLikeMarkdown(text)) {
  const html = markdownToHtml(text);
}

import {
  loadGoogleFonts,
  addFonts,
  removeFonts,
} from '@remyxjs/core';

// Load Google Fonts (injects <link> into <head>)
loadGoogleFonts(['Roboto', 'Open Sans', 'Merriweather']);

// With Subresource Integrity (SRI) hash for security
loadGoogleFonts(['Roboto'], {
  integrity: 'sha384-abc123...', // pre-computed hash of the stylesheet
  crossOrigin: 'anonymous', // required for SRI (default)
});

// Modify a font list
const fonts = ['Arial', 'Georgia', 'Times New Roman'];
const updated = addFonts(fonts, ['Roboto', 'Lato'], { position: 0 });
// ['Roboto', 'Lato', 'Arial', 'Georgia', 'Times New Roman']

const trimmed = removeFonts(updated, ['Times New Roman']);
// ['Roboto', 'Lato', 'Arial', 'Georgia']

import {
  closestBlock,
  closestTag,
  wrapInTag,
  unwrapTag,
  generateId,
  isBlockEmpty,
} from '@remyxjs/core';

closestBlock(node, editorElement); // Nearest block ancestor
closestTag(node, 'a', editorElement); // Nearest <a> ancestor
wrapInTag(range, 'mark', { class: 'hi' }); // Wrap range in element
unwrapTag(markElement); // Unwrap, keep children
generateId(); // 'rmx-a1b2c3d4'
isBlockEmpty(paragraphElement); // true if no meaningful content

import { formatHTML } from '@remyxjs/core';

const pretty = formatHTML('<div><p>Hello</p><p>World</p></div>');
// <div>
//   <p>Hello</p>
//   <p>World</p>
// </div>

import { isMac, getModKey } from '@remyxjs/core';

isMac(); // true on macOS
getModKey(); // 'Cmd' on Mac, 'Ctrl' on Windows/Linux

document
  .querySelector('.rmx-editor')
  .classList.add('rmx-theme-ocean');

import { THEME_PRESETS, createTheme } from '@remyxjs/core';
// Override a single variable on top of ocean
const modified = {
  ...THEME_PRESETS.ocean,
  ...createTheme({ primary: '#ff6b6b' }),
};

import { createTheme } from '@remyxjs/core';

// Use camelCase keys (automatically mapped to --rmx-* CSS vars)
const theme = createTheme({
  bg: '#1e1e2e',
  text: '#cdd6f4',
  border: '#45475a',
  toolbarBg: '#181825',
  toolbarText: '#cdd6f4',
  primary: '#89b4fa',
  radius: '8px',
});

// Apply to an editor wrapper element
Object.entries(theme).forEach(([prop, value]) => {
  editorWrapper.style.setProperty(prop, value);
});

const theme = createTheme({
  '--rmx-bg': '#1e1e2e',
  '--rmx-text': '#cdd6f4',
});

import { TOOLBAR_PRESETS } from '@remyxjs/core';

// Available presets:
TOOLBAR_PRESETS.full; // All available items including plugin commands
TOOLBAR_PRESETS.rich; // All features with plugin toolbar items (callout, math, toc, bookmark, merge tag)
TOOLBAR_PRESETS.standard; // Common editing features without plugins
TOOLBAR_PRESETS.minimal; // Basic text formatting
TOOLBAR_PRESETS.bare; // Bold, italic, underline only

[
  ['bold', 'italic', 'underline'], // Group 1
  ['heading', 'orderedList', 'unorderedList'], // Group 2
  ['link', 'image'], // Group 3
];

import {
  removeToolbarItems,
  addToolbarItems,
  createToolbar,
  TOOLBAR_PRESETS,
} from '@remyxjs/core';

// Start from a preset and customize
let toolbar = TOOLBAR_PRESETS.standard;

// Remove items
toolbar = removeToolbarItems(toolbar, [
  'strikethrough',
  'subscript',
  'superscript',
]);

// Add items to a specific group or position
toolbar = addToolbarItems(toolbar, ['codeBlock', 'blockquote'], {
  position: 'after', // 'before' | 'after' | 'start' | 'end'
  relativeTo: 'link', // existing item to position relative to
});

// Or build from scratch
const myToolbar = createToolbar([
  ['bold', 'italic', 'underline'],
  ['heading'],
  ['orderedList', 'unorderedList'],
  ['link'],
  ['undo', 'redo'],
]);

import {
  createToolbarItemTheme,
  resolveToolbarItemStyle,
} from '@remyxjs/core';

const itemTheme = createToolbarItemTheme({
  bold: {
    color: '#e74c3c',
    activeBackground: '#fce4ec',
  },
  heading: {
    fontSize: '14px',
    fontWeight: '600',
  },
});

import { defineConfig } from '@remyxjs/core';

const config = defineConfig({
  // Shared defaults for all editors
  toolbar: TOOLBAR_PRESETS.standard,
  theme: THEME_PRESETS.ocean,

  // Named editor variants
  editors: {
    blog: {
      toolbar: TOOLBAR_PRESETS.full,
      outputFormat: 'html',
    },
    comments: {
      toolbar: TOOLBAR_PRESETS.minimal,
      outputFormat: 'markdown',
      history: { maxSize: 50 },
    },
  },
});

import { loadConfig } from '@remyxjs/core';

// JSON config
const config = await loadConfig(
  'https://cdn.example.com/editor-config.json',
);

// YAML config (detected by .yml/.yaml extension)
const config = await loadConfig('/configs/editor.yaml');

// Environment-based merging
const config = await loadConfig('/config.json', {
  env: 'production',
});

// Custom headers (e.g., authenticated endpoints)
const config = await loadConfig('/api/editor-config', {
  headers: { Authorization: 'Bearer token123' },
});

// Cancellation
const controller = new AbortController();
const config = await loadConfig('/config.json', {
  signal: controller.signal,
});

import { EditorBus } from '@remyxjs/core';

// Register editors so they can be looked up by ID
EditorBus.register('source', sourceEngine);
EditorBus.register('preview', previewEngine);

// Editor A broadcasts content on every change
sourceEngine.on('content:change', () => {
  EditorBus.emit('sync:content', {
    id: 'source',
    html: sourceEngine.getHTML(),
  });
});

// Editor B listens for updates
EditorBus.on('sync:content', ({ id, html }) => {
  if (id !== 'preview') {
    previewEngine.setHTML(html);
  }
});

// Broadcast a theme change into every editor's local event loop
EditorBus.broadcast('theme:change', { theme: 'dark' });

// Broadcast to all except the sender
EditorBus.broadcast('sync:content', { html }, { exclude: 'source' });

// Look up a registered editor
const engine = EditorBus.getEditor('preview');

// List all registered IDs
console.log(EditorBus.getEditorIds()); // ['source', 'preview']

// Unregister on destroy
EditorBus.unregister('source');

import { SharedResources } from '@remyxjs/core';

// Shared, frozen sanitizer schema
const { allowedTags, allowedStyles } =
  SharedResources.sanitizerSchema;

// Shared toolbar presets
const fullToolbar = SharedResources.toolbarPresets.full;

// Shared defaults (toolbar, menuBar, fonts, fontSizes, colors, headingOptions)
const defaultFonts = SharedResources.defaults.fonts;

// Shared keybinding table
const keybindings = SharedResources.keybindings;

// Shared command metadata (buttons, tooltips, shortcuts, modals)
const tooltips = SharedResources.commands.tooltips;

// Register a custom icon once, available to all editors
SharedResources.registerIcon(
  'myAction',
  '<svg viewBox="0 0 24 24">...</svg>',
);
SharedResources.getIcon('myAction'); // '<svg ...>'
SharedResources.getIconNames(); // ['myAction']
SharedResources.unregisterIcon('myAction');

// Stats
SharedResources.stats; // { registeredIcons: 0, frozenSchemas: true }

import {
  // Toolbar & menu defaults
  DEFAULT_TOOLBAR, // Full toolbar configuration
  DEFAULT_MENU_BAR, // Menu bar structure

  // Font & color defaults
  DEFAULT_FONTS, // Array of font family names
  DEFAULT_FONT_SIZES, // Array of size strings
  DEFAULT_COLORS, // Color palette array

  // Keyboard
  DEFAULT_KEYBINDINGS, // Map: command name → shortcut string

  // Heading options
  HEADING_OPTIONS, // H1-H6 + paragraph

  // Security schema
  ALLOWED_TAGS, // Tag → allowed attributes map
  ALLOWED_STYLES, // Allowed CSS property names

  // Command metadata
  BUTTON_COMMANDS, // Set of commands rendered as buttons
  TOOLTIP_MAP, // Command → tooltip text
  SHORTCUT_MAP, // Command → display shortcut
  MODAL_COMMANDS, // Commands that open modals
  getShortcutLabel, // (command) => platform-aware label string
  getCommandActiveState, // (command, selectionState, engine) => boolean

  // Command palette
  SLASH_COMMAND_ITEMS, // Default catalog of command palette items
  filterSlashItems, // (items, query, options?) => filtered items (pinRecent: true by default)
  getRecentCommands, // () => string[] — last 5 executed command IDs
  recordRecentCommand, // (id) => void — record a command execution
  clearRecentCommands, // () => void — clear recent history
  registerCommandItems, // (items) => void — add custom items to the palette
  unregisterCommandItem, // (id) => boolean — remove a custom item
  getCustomCommandItems, // () => SlashCommandItem[] — get all custom items

  // Comments & Annotations
  CommentsPlugin, // Inline comment threads plugin
  parseMentions, // (text) => string[] — extract @mentions from text

  // Callouts & Alerts
  CalloutPlugin, // Styled callout blocks plugin
  registerCalloutType, // (typeDef) => void — register custom callout type
  unregisterCalloutType, // (type) => boolean — remove a callout type
  getCalloutTypes, // () => CalloutType[] — all registered types
  getCalloutType, // (type) => CalloutType — get a type definition
  parseGFMAlert, // (text) => { type, body } — parse GFM alert syntax

  // Advanced Link Management
  LinkPlugin, // Link previews, broken links, auto-link, bookmarks
  detectLinks, // (text) => Array<{ type, value, index }>
  slugify, // (text) => URL-safe slug string

  // Template System
  TemplatePlugin, // Merge tags, conditionals, loops, preview, library
  renderTemplate, // (template, data) => rendered string
  extractTags, // (template) => string[] — unique tag names
  registerTemplate, // Add custom template to library
  unregisterTemplate, // Remove template from library
  getTemplateLibrary, // () => all templates
  getTemplate, // (id) => template by ID

  // Keyboard-First Editing
  KeyboardPlugin, // Vim/Emacs modes, auto-pair, multi-cursor
  getHeadings, // (element) => heading list with level/text/element
  selectNextOccurrence, // (element) => add next match to selection

  // Drag & Drop
  DragDropPlugin, // Drop zones, cross-editor, file drops, reorder

  // Math & Equations
  MathPlugin, // LaTeX math rendering, symbol palette, numbering
  getSymbolPalette, // () => categorized symbol array
  parseMathExpressions, // (text) => Array<{ type, src, index }>
  latexToMathML, // (latex) => MathML string

  // Table of Contents
  TocPlugin, // Auto-generated TOC, outline, heading validation
  buildOutline, // (element) => hierarchical outline tree
  flattenOutline, // (outline) => flat item list
  renderTocHTML, // (outline) => HTML nav string
  validateHeadingHierarchy, // (flatItems) => warnings array

  // Content Analytics
  AnalyticsPlugin, // Readability, reading time, SEO, goals
  analyzeContent, // (text, options) => comprehensive stats
  countSyllables, // (word) => number
  splitSentences, // (text) => string[]
  fleschKincaid, // (stats) => grade level
  fleschReadingEase, // (stats) => 0-100 score
  gunningFog, // (stats) => fog index
  colemanLiau, // (stats) => index
  vocabularyLevel, // (gradeLevel) => 'basic'|'intermediate'|'advanced'
  keywordDensity, // (text, keyword) => { count, density, positions }
  seoAnalysis, // (text, element, keyword) => { hints, ... }

  // Spelling & Grammar
  SpellcheckPlugin, // Spellcheck + grammar checking with inline underlines
  analyzeGrammar, // (text, options) => issues array
  summarizeIssues, // (issues) => { total, grammar, style, byRule }
  detectPassiveVoice, // (text) => issues
  detectWordiness, // (text) => issues
  detectCliches, // (text) => issues
  detectPunctuationIssues, // (text) => issues
  STYLE_PRESETS, // { formal, casual, technical, academic }

  // Real-time Collaboration
  CollaborationPlugin, // CRDT co-editing, live cursors, presence, transport

  // Plugin registry
  registerPluginInRegistry, // Register a plugin for discovery
  unregisterPluginFromRegistry, // Remove from registry
  listRegisteredPlugins, // () => PluginRegistryEntry[] — all registered
  searchPluginRegistry, // (query) => PluginRegistryEntry[] — search by name/desc/tags
} from '@remyxjs/core';