@jackuait/blok 0.4.1-beta.5 → 0.4.1-beta.6

package/codemod/migrate-editorjs-to-blok.js

@@ -29,28 +29,523 @@ const path = require('path');
 
 const FILE_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.html', '.css', '.scss', '.less'];
 
+// ============================================================================
+// i18n Transformation Utilities
+// ============================================================================
+
+/**
+ * EditorJS to Blok key mappings for keys that changed.
+ * These are applied after flattening to convert EditorJS keys to Blok equivalents.
+ *
+ * EditorJS keys reference: https://editorjs.io/i18n/
+ * Blok keys reference: src/components/i18n/locales/en/messages.json
+ */
+const I18N_KEY_MAPPINGS = {
+  // UI keys that changed
+  'ui.blockTunes.toggler.Click to tune': 'blockSettings.clickToOpenMenu',
+  'ui.blockTunes.toggler.or drag to move': 'blockSettings.dragToMove',
+  'ui.toolbar.toolbox.Add': 'toolbox.addBelow',
+  'ui.inlineToolbar.converter.Convert to': 'popover.convertTo',
+  'ui.popover.Filter': 'popover.search',
+
+  // Tool names that changed (EditorJS uses different casing/wording)
+  'toolNames.Ordered List': 'toolNames.numberedList',
+  'toolNames.Unordered List': 'toolNames.bulletedList',
+
+  // Tools messages that changed
+  'tools.stub.The block can not be displayed correctly': 'tools.stub.blockCannotBeDisplayed',
+  'tools.stub.The block can not be displayed correctly.': 'tools.stub.blockCannotBeDisplayed',
+
+  // Block tunes that changed in Blok
+  'blockTunes.delete.Delete': 'blockSettings.delete',
+
+  // Block tunes that are removed in Blok (moveUp/moveDown replaced with drag)
+  // These are mapped to null to indicate they should be removed
+  'blockTunes.moveUp.Move up': null,
+  'blockTunes.moveDown.Move down': null,
+};
+
+/**
+ * Namespace mappings from old verbose prefixes to new simplified prefixes.
+ * Applied after camelCase normalization.
+ */
+const NAMESPACE_MAPPINGS = {
+  'ui.blockTunes.toggler': 'blockSettings',
+  'ui.toolbar.toolbox': 'toolbox',
+  'ui.popover': 'popover',
+  'blockTunes': 'blockSettings',
+};
+
+/**
+ * Converts an EditorJS-style key (with English text) to Blok-style (camelCase).
+ * Blok uses camelCase for the final segment of translation keys.
+ * Also applies namespace simplification for known verbose prefixes.
+ * Example: 'ui.popover.Nothing found' → 'popover.nothingFound'
+ * Example: 'toolNames.Text' → 'toolNames.text'
+ * @param {string} key - The dot-notation key with English text
+ * @returns {string} The normalized key with camelCase final segment
+ */
+function normalizeKey(key) {
+  const parts = key.split('.');
+  const lastPart = parts[parts.length - 1];
+
+  // Convert "Nothing found" → "nothingFound", "Text" → "text"
+  const words = lastPart.split(/\s+/);
+  const camelCase = words
+    .map((word, i) => {
+      if (i === 0) {
+        // First word is lowercase
+        return word.toLowerCase();
+      }
+      // Subsequent words have first letter capitalized
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+    .join('');
+
+  parts[parts.length - 1] = camelCase;
+  let normalizedKey = parts.join('.');
+
+  // Apply namespace mappings (longest prefix first for correct matching)
+  const sortedPrefixes = Object.keys(NAMESPACE_MAPPINGS).sort((a, b) => b.length - a.length);
+  for (const oldPrefix of sortedPrefixes) {
+    if (normalizedKey.startsWith(oldPrefix + '.')) {
+      normalizedKey = NAMESPACE_MAPPINGS[oldPrefix] + normalizedKey.slice(oldPrefix.length);
+      break;
+    }
+  }
+
+  return normalizedKey;
+}
+
+/**
+ * Flattens a nested i18n dictionary object to Blok's flat dot-notation format.
+ * @param {Object} obj - The nested dictionary object
+ * @param {string} prefix - Current key prefix (for recursion)
+ * @returns {Object} Flattened dictionary with dot-notation keys
+ */
+function flattenI18nDictionary(obj, prefix = '') {
+  const result = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      Object.assign(result, flattenI18nDictionary(value, newKey));
+    } else {
+      // Check explicit mappings first, otherwise normalize to camelCase
+      let finalKey;
+      if (newKey in I18N_KEY_MAPPINGS) {
+        finalKey = I18N_KEY_MAPPINGS[newKey];
+      } else {
+        finalKey = normalizeKey(newKey);
+      }
+
+      // Skip keys that are mapped to null (removed in Blok)
+      if (finalKey === null) {
+        continue;
+      }
+
+      result[finalKey] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Parses a JavaScript object literal string into an actual object.
+ * Handles simple object literals with string values.
+ * @param {string} str - The object literal string
+ * @returns {Object|null} Parsed object or null if parsing fails
+ */
+function parseObjectLiteral(str) {
+  try {
+    // Convert single quotes to double quotes for JSON compatibility
+    // Handle unquoted keys by quoting them
+    let jsonStr = str
+      // Replace single quotes with double quotes
+      .replace(/'/g, '"')
+      // Handle unquoted keys (identifier followed by colon)
+      .replace(/(\s*)(\w+)(\s*:\s*)/g, '$1"$2"$3')
+      // Remove trailing commas before closing braces/brackets
+      .replace(/,(\s*[}\]])/g, '$1');
+
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Converts a flattened dictionary object to a formatted JavaScript object string.
+ * @param {Object} obj - The flattened dictionary
+ * @param {string} indent - The indentation string
+ * @returns {string} Formatted object string
+ */
+function objectToString(obj, indent = '      ') {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) {
+    return '{}';
+  }
+
+  const lines = entries.map(([key, value]) => {
+    const escapedValue = typeof value === 'string' ? value.replace(/"/g, '\\"') : value;
+    return `${indent}"${key}": "${escapedValue}"`;
+  });
+
+  return '{\n' + lines.join(',\n') + '\n' + indent.slice(2) + '}';
+}
+
+/**
+ * Finds matching brace for nested object parsing.
+ * @param {string} str - The string to search
+ * @param {number} startIndex - Starting position (should be at opening brace)
+ * @returns {number} Index of matching closing brace, or -1 if not found
+ */
+function findMatchingBrace(str, startIndex) {
+  let depth = 0;
+  let inString = false;
+  let stringChar = '';
+
+  for (let i = startIndex; i < str.length; i++) {
+    const char = str[i];
+    const prevChar = i > 0 ? str[i - 1] : '';
+
+    // Handle string detection
+    if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (inString) continue;
+
+    if (char === '{') {
+      depth++;
+    } else if (char === '}') {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+
+  return -1;
+}
+
+/**
+ * Transforms EditorJS nested i18n messages to Blok flat format.
+ * @param {string} content - The file content
+ * @returns {{result: string, changed: boolean}} Transformed content and change flag
+ */
+function transformI18nConfig(content) {
+  // Pattern to find i18n: { messages: { ... } } or i18n: { messages: { ... }, ... }
+  const i18nStartPattern = /i18n\s*:\s*\{\s*messages\s*:\s*\{/g;
+  let match;
+  let result = content;
+  let changed = false;
+  let offset = 0;
+
+  // Reset lastIndex for the regex
+  i18nStartPattern.lastIndex = 0;
+
+  while ((match = i18nStartPattern.exec(content)) !== null) {
+    const messagesStart = match.index + match[0].length - 1; // Position of opening brace of messages
+    const messagesEnd = findMatchingBrace(content, messagesStart);
+
+    if (messagesEnd === -1) continue;
+
+    const messagesStr = content.substring(messagesStart, messagesEnd + 1);
+
+    // Skip if it contains functions or arrow functions (dynamic content)
+    if (messagesStr.includes('function') || messagesStr.includes('=>')) {
+      continue;
+    }
+
+    // Try to parse the messages object
+    const messagesObj = parseObjectLiteral(messagesStr);
+    if (!messagesObj) continue;
+
+    // Flatten the dictionary
+    const flattened = flattenI18nDictionary(messagesObj);
+
+    // Detect indentation from the original content
+    const lineStart = content.lastIndexOf('\n', match.index) + 1;
+    const lineContent = content.substring(lineStart, match.index);
+    const baseIndent = lineContent.match(/^\s*/)?.[0] || '';
+    const messagesIndent = baseIndent + '    ';
+
+    // Convert to string with proper formatting
+    const flattenedStr = objectToString(flattened, messagesIndent + '  ');
+
+    // Replace in result (accounting for previous replacements)
+    const adjustedStart = messagesStart + offset;
+    const adjustedEnd = messagesEnd + 1 + offset;
+    result = result.substring(0, adjustedStart) + flattenedStr + result.substring(adjustedEnd);
+
+    // Update offset for next iteration
+    offset += flattenedStr.length - (messagesEnd + 1 - messagesStart);
+    changed = true;
+  }
+
+  return { result, changed };
+}
+
+/**
+ * Removes i18n messages from config to use Blok's built-in library translations.
+ * Preserves other i18n properties like locale and direction.
+ * @param {string} content - The file content
+ * @returns {{result: string, changed: boolean}} Transformed content and change flag
+ */
+function removeI18nMessages(content) {
+  // Pattern to find i18n config with messages property
+  const i18nStartPattern = /i18n\s*:\s*\{/g;
+  let match;
+  let result = content;
+  let changed = false;
+  let offset = 0;
+
+  // Reset lastIndex for the regex
+  i18nStartPattern.lastIndex = 0;
+
+  while ((match = i18nStartPattern.exec(content)) !== null) {
+    const i18nStart = match.index + match[0].length - 1; // Position of opening brace
+    const i18nEnd = findMatchingBrace(content, i18nStart);
+
+    if (i18nEnd === -1) continue;
+
+    const i18nContent = content.substring(i18nStart, i18nEnd + 1);
+
+    // Check if this i18n config has a messages property
+    if (!i18nContent.includes('messages')) {
+      continue;
+    }
+
+    // Find the messages property and remove it
+    // Handle: messages: { ... }, or messages: { ... } (with or without trailing comma)
+    const messagesPattern = /,?\s*messages\s*:\s*\{/;
+    const messagesMatch = i18nContent.match(messagesPattern);
+
+    if (!messagesMatch) continue;
+
+    const messagesStartInContent = i18nContent.indexOf(messagesMatch[0]);
+    const messagesObjStart = i18nContent.indexOf('{', messagesStartInContent);
+    const messagesObjEnd = findMatchingBrace(i18nContent, messagesObjStart);
+
+    if (messagesObjEnd === -1) continue;
+
+    // Determine what to remove (including trailing comma if present)
+    let removeStart = messagesStartInContent;
+    let removeEnd = messagesObjEnd + 1;
+
+    // Check for trailing comma after messages object
+    const afterMessages = i18nContent.substring(removeEnd);
+    const trailingCommaMatch = afterMessages.match(/^\s*,/);
+    if (trailingCommaMatch) {
+      removeEnd += trailingCommaMatch[0].length;
+    }
+
+    // If messages started with a comma (not first property), include it in removal
+    // Otherwise, we need to handle the case where it's the first property
+    const beforeMessages = i18nContent.substring(0, messagesStartInContent);
+    if (!messagesMatch[0].startsWith(',') && beforeMessages.trim() === '{') {
+      // messages is first property, remove trailing comma if any
+    }
+
+    // Build the new i18n content without messages
+    let newI18nContent = i18nContent.substring(0, removeStart) + i18nContent.substring(removeEnd);
+
+    // Clean up: remove leading comma if messages was removed and left one
+    newI18nContent = newI18nContent.replace(/\{\s*,/, '{');
+
+    // Clean up: remove trailing comma before closing brace
+    newI18nContent = newI18nContent.replace(/,\s*\}/, ' }');
+
+    // Clean up empty i18n config: { } -> remove or simplify
+    const isEmptyI18n = newI18nContent.replace(/\s/g, '') === '{}';
+
+    if (isEmptyI18n) {
+      // Replace with empty object or keep minimal
+      newI18nContent = '{}';
+    }
+
+    // Replace in result (accounting for previous replacements)
+    const adjustedI18nStart = i18nStart + offset;
+    const adjustedI18nEnd = i18nEnd + 1 + offset;
+    result = result.substring(0, adjustedI18nStart) + newI18nContent + result.substring(adjustedI18nEnd);
+
+    // Update offset for next iteration
+    offset += newI18nContent.length - (i18nEnd + 1 - i18nStart);
+    changed = true;
+  }
+
+  return { result, changed };
+}
+
 // Import transformations
 const IMPORT_TRANSFORMS = [
-  // Main EditorJS import
+  // EditorJS subpath imports (e.g., @editorjs/editorjs/types -> @jackuait/blok/types)
+  {
+    pattern: /from\s+['"]@editorjs\/editorjs\/([^'"]+)['"]/g,
+    replacement: "from '@jackuait/blok/$1'",
+  },
+  {
+    pattern: /require\s*\(\s*['"]@editorjs\/editorjs\/([^'"]+)['"]\s*\)/g,
+    replacement: "require('@jackuait/blok/$1')",
+  },
+  // Combined default + named imports: import EditorJS, { EditorConfig } from '@editorjs/editorjs'
+  // → import { Blok, EditorConfig } from '@jackuait/blok' (EditorConfig → BlokConfig handled by TYPE_TRANSFORMS)
+  // IMPORTANT: Must come before regular default import patterns to avoid partial matching
+  {
+    pattern: /import\s+EditorJS\s*,\s*\{\s*([^}]+?)\s*\}\s*from\s+['"]@editorjs\/editorjs['"]/g,
+    replacement: "import { Blok, $1 } from '@jackuait/blok'",
+    note: 'Converted combined default + named import',
+  },
+  // Aliased combined: import Editor, { EditorConfig } from '@editorjs/editorjs'
   {
-    pattern: /from\s+['"]@editorjs\/editorjs['"]/g,
-    replacement: "from '@jackuait/blok'",
+    pattern: /import\s+(\w+)\s*,\s*\{\s*([^}]+?)\s*\}\s*from\s+['"]@editorjs\/editorjs['"]/g,
+    replacement: "import { Blok as $1, $2 } from '@jackuait/blok'",
+    note: 'Converted aliased combined default + named import',
+  },
+  // Main EditorJS default import -> Blok named import
+  // e.g., import EditorJS from '@editorjs/editorjs' -> import { Blok } from '@jackuait/blok'
+  {
+    pattern: /import\s+EditorJS\s+from\s+['"]@editorjs\/editorjs['"]/g,
+    replacement: "import { Blok } from '@jackuait/blok'",
+    note: 'Converted default import to named import',
+  },
+  // EditorJS default import with alias -> Blok named import with alias
+  // e.g., import Editor from '@editorjs/editorjs' -> import { Blok as Editor } from '@jackuait/blok'
+  {
+    pattern: /import\s+(\w+)\s+from\s+['"]@editorjs\/editorjs['"]/g,
+    replacement: "import { Blok as $1 } from '@jackuait/blok'",
+    note: 'Converted default import to named import with alias',
+  },
+  // Destructured require with default: const { default: EditorJS } = require(...)
+  // IMPORTANT: Must come before generic require pattern to avoid partial matching
+  {
+    pattern: /const\s+\{\s*default\s*:\s*(\w+)\s*\}\s*=\s*require\s*\(\s*['"]@editorjs\/editorjs['"]\s*\)/g,
+    replacement: "const { Blok: $1 } = require('@jackuait/blok')",
+    note: 'Converted destructured default require to named require',
   },
   {
     pattern: /require\s*\(\s*['"]@editorjs\/editorjs['"]\s*\)/g,
-    replacement: "require('@jackuait/blok')",
+    replacement: "require('@jackuait/blok').Blok",
+  },
+  // Namespace import: import * as EditorJS from '@editorjs/editorjs'
+  // → convert to named import (namespace pattern no longer needed with named exports)
+  {
+    pattern: /import\s+\*\s+as\s+(\w+)\s+from\s+['"]@editorjs\/editorjs['"]/g,
+    replacement: "import { Blok as $1 } from '@jackuait/blok'",
+    note: 'Converted namespace import to named import (namespace no longer needed)',
+  },
+  // Dynamic import with .then chaining that expects default (must come before generic dynamic import)
+  {
+    pattern: /import\s*\(\s*['"]@editorjs\/editorjs['"]\s*\)\s*\.then\s*\(\s*(\w+)\s*=>\s*\1\.default\s*\)/g,
+    replacement: "import('@jackuait/blok').then($1 => $1.Blok)",
+    note: 'Converted dynamic import .then(m => m.default) pattern',
+  },
+  // Dynamic import with destructuring: const { default: Editor } = await import('@editorjs/editorjs')
+  // IMPORTANT: Must come before generic dynamic import to avoid partial matching
+  {
+    pattern: /\{\s*default\s*:\s*(\w+)\s*\}\s*=\s*await\s+import\s*\(\s*['"]@editorjs\/editorjs['"]\s*\)/g,
+    replacement: "{ Blok: $1 } = await import('@jackuait/blok')",
+    note: 'Converted destructured dynamic import',
+  },
+  // Dynamic import: import('@editorjs/editorjs')
+  {
+    pattern: /import\s*\(\s*['"]@editorjs\/editorjs['"]\s*\)/g,
+    replacement: "import('@jackuait/blok').then(m => ({ default: m.Blok }))",
+    note: 'Converted dynamic import (wraps named export as default for compatibility)',
+  },
+  // Type-only default import: import type EditorJS from '@editorjs/editorjs'
+  {
+    pattern: /import\s+type\s+(\w+)\s+from\s+['"]@editorjs\/editorjs['"]/g,
+    replacement: "import type { Blok as $1 } from '@jackuait/blok'",
+    note: 'Converted type-only default import to named import',
+  },
+  // Re-export default as named: export { default as Editor } from '@editorjs/editorjs'
+  {
+    pattern: /export\s+\{\s*default\s+as\s+(\w+)\s*\}\s*from\s+['"]@editorjs\/editorjs['"]/g,
+    replacement: "export { Blok as $1 } from '@jackuait/blok'",
+    note: 'Converted default re-export to named export',
+  },
+  // Re-export default: export { default } from '@editorjs/editorjs'
+  {
+    pattern: /export\s+\{\s*default\s*\}\s*from\s+['"]@editorjs\/editorjs['"]/g,
+    replacement: "export { Blok } from '@jackuait/blok'",
+    note: 'Converted default re-export',
+  },
+  // Header tool (now bundled) - import directly from @jackuait/blok
+  {
+    pattern: /import\s+Header\s+from\s+['"]@editorjs\/header['"];?\n?/g,
+    replacement: "import { Header } from '@jackuait/blok';\n",
+    note: 'Header tool is now bundled with Blok',
   },
-  // Header tool (now bundled)
   {
     pattern: /import\s+(\w+)\s+from\s+['"]@editorjs\/header['"];?\n?/g,
-    replacement: '// Header is now bundled with Blok: use Blok.Header\n',
-    note: 'Header tool is now bundled',
+    replacement: "import { Header as $1 } from '@jackuait/blok';\n",
+    note: 'Header tool is now bundled with Blok (aliased)',
+  },
+  // Paragraph tool (now bundled) - import directly from @jackuait/blok
+  {
+    pattern: /import\s+Paragraph\s+from\s+['"]@editorjs\/paragraph['"];?\n?/g,
+    replacement: "import { Paragraph } from '@jackuait/blok';\n",
+    note: 'Paragraph tool is now bundled with Blok',
   },
-  // Paragraph tool (now bundled)
   {
     pattern: /import\s+(\w+)\s+from\s+['"]@editorjs\/paragraph['"];?\n?/g,
-    replacement: '// Paragraph is now bundled with Blok: use Blok.Paragraph\n',
-    note: 'Paragraph tool is now bundled',
+    replacement: "import { Paragraph as $1 } from '@jackuait/blok';\n",
+    note: 'Paragraph tool is now bundled with Blok (aliased)',
+  },
+  // List tool (now bundled) - import directly from @jackuait/blok
+  {
+    pattern: /import\s+List\s+from\s+['"]@editorjs\/list['"];?\n?/g,
+    replacement: "import { List } from '@jackuait/blok';\n",
+    note: 'List tool is now bundled with Blok',
+  },
+  {
+    pattern: /import\s+(\w+)\s+from\s+['"]@editorjs\/list['"];?\n?/g,
+    replacement: "import { List as $1 } from '@jackuait/blok';\n",
+    note: 'List tool is now bundled with Blok (aliased)',
+  },
+  // Tool require statements (CommonJS)
+  // Header require: const Header = require('@editorjs/header')
+  {
+    pattern: /const\s+Header\s*=\s*require\s*\(\s*['"]@editorjs\/header['"]\s*\)/g,
+    replacement: "const { Header } = require('@jackuait/blok')",
+    note: 'Header tool is now bundled with Blok',
+  },
+  {
+    pattern: /const\s+(\w+)\s*=\s*require\s*\(\s*['"]@editorjs\/header['"]\s*\)/g,
+    replacement: "const { Header: $1 } = require('@jackuait/blok')",
+    note: 'Header tool is now bundled with Blok (aliased)',
+  },
+  // Paragraph require
+  {
+    pattern: /const\s+Paragraph\s*=\s*require\s*\(\s*['"]@editorjs\/paragraph['"]\s*\)/g,
+    replacement: "const { Paragraph } = require('@jackuait/blok')",
+    note: 'Paragraph tool is now bundled with Blok',
+  },
+  {
+    pattern: /const\s+(\w+)\s*=\s*require\s*\(\s*['"]@editorjs\/paragraph['"]\s*\)/g,
+    replacement: "const { Paragraph: $1 } = require('@jackuait/blok')",
+    note: 'Paragraph tool is now bundled with Blok (aliased)',
+  },
+  // List require
+  {
+    pattern: /const\s+List\s*=\s*require\s*\(\s*['"]@editorjs\/list['"]\s*\)/g,
+    replacement: "const { List } = require('@jackuait/blok')",
+    note: 'List tool is now bundled with Blok',
+  },
+  {
+    pattern: /const\s+(\w+)\s*=\s*require\s*\(\s*['"]@editorjs\/list['"]\s*\)/g,
+    replacement: "const { List: $1 } = require('@jackuait/blok')",
+    note: 'List tool is now bundled with Blok (aliased)',
   },
 ];
 
@@ -122,13 +617,13 @@ const CSS_CLASS_TRANSFORMS = [
   { pattern: /(['"`])ce-inline-toolbar(['"`])/g, replacement: '$1data-blok-testid="inline-toolbar"$2' },
 
   // Popover classes (ce-popover)
-  { pattern: /\.ce-popover--opened(?![\w-])/g, replacement: '[data-blok-popover][data-blok-opened="true"]' },
+  { pattern: /\.ce-popover--opened(?![\w-])/g, replacement: '[data-blok-popover-opened="true"]' },
   { pattern: /\.ce-popover__container(?![\w-])/g, replacement: '[data-blok-popover-container]' },
   { pattern: /\.ce-popover-item--focused(?![\w-])/g, replacement: '[data-blok-focused="true"]' },
   { pattern: /\.ce-popover-item(?![\w-])/g, replacement: '[data-blok-testid="popover-item"]' },
   { pattern: /\.ce-popover(?![\w-])/g, replacement: '[data-blok-popover]' },
   // Without dot prefix
-  { pattern: /(['"`])ce-popover--opened(['"`])/g, replacement: '$1data-blok-popover$2' },
+  { pattern: /(['"`])ce-popover--opened(['"`])/g, replacement: '$1data-blok-popover-opened$2' },
   { pattern: /(['"`])ce-popover__container(['"`])/g, replacement: '$1data-blok-popover-container$2' },
   { pattern: /(['"`])ce-popover-item--focused(['"`])/g, replacement: '$1data-blok-focused$2' },
   { pattern: /(['"`])ce-popover-item(['"`])/g, replacement: '$1data-blok-testid="popover-item"$2' },
@@ -166,17 +661,17 @@ const CSS_CLASS_TRANSFORMS = [
   { pattern: /(['"`])ce-ragged-right(['"`])/g, replacement: '$1data-blok-ragged-right$2' },
 
   // Popover item states and icons
-  { pattern: /\.ce-popover-item--confirmation(?![\w-])/g, replacement: '[data-blok-confirmation="true"]' },
+  { pattern: /\.ce-popover-item--confirmation(?![\w-])/g, replacement: '[data-blok-popover-item-confirmation="true"]' },
   { pattern: /\.ce-popover-item__icon(?![\w-])/g, replacement: '[data-blok-testid="popover-item-icon"]' },
   { pattern: /\.ce-popover-item__icon--tool(?![\w-])/g, replacement: '[data-blok-testid="popover-item-icon-tool"]' },
-  { pattern: /(['"`])ce-popover-item--confirmation(['"`])/g, replacement: '$1data-blok-confirmation$2' },
+  { pattern: /(['"`])ce-popover-item--confirmation(['"`])/g, replacement: '$1data-blok-popover-item-confirmation$2' },
   { pattern: /(['"`])ce-popover-item__icon(['"`])/g, replacement: '$1data-blok-testid="popover-item-icon"$2' },
   { pattern: /(['"`])ce-popover-item__icon--tool(['"`])/g, replacement: '$1data-blok-testid="popover-item-icon-tool"$2' },
 
   // Toolbox classes (ce-toolbox)
-  { pattern: /\.ce-toolbox--opened(?![\w-])/g, replacement: '[data-blok-toolbox][data-blok-opened="true"]' },
+  { pattern: /\.ce-toolbox--opened(?![\w-])/g, replacement: '[data-blok-toolbox-opened="true"]' },
   { pattern: /\.ce-toolbox(?![\w-])/g, replacement: '[data-blok-toolbox]' },
-  { pattern: /(['"`])ce-toolbox--opened(['"`])/g, replacement: '$1data-blok-toolbox$2' },
+  { pattern: /(['"`])ce-toolbox--opened(['"`])/g, replacement: '$1data-blok-toolbox-opened$2' },
   { pattern: /(['"`])ce-toolbox(['"`])/g, replacement: '$1data-blok-toolbox$2' },
 
   // CDX list classes (cdx-list)
@@ -240,19 +735,141 @@ const HOLDER_TRANSFORMS = [
   { pattern: /getElementById\s*\(\s*['"]editorjs['"]\s*\)/g, replacement: "getElementById('blok')" },
 ];
 
-// Bundled tools - add new tools here as they are bundled with Blok
-const BUNDLED_TOOLS = ['Header', 'Paragraph'];
+// Bundled tools - these are now in a separate entry point (@jackuait/blok/tools)
+const BUNDLED_TOOLS = ['Header', 'Paragraph', 'List'];
+
+// Inline tools - also in the tools entry point
+const INLINE_TOOLS = ['Bold', 'Italic', 'Link'];
+
+// Internal tools - these are bundled with core and don't need to be imported
+const INTERNAL_TOOLS = ['Convert', 'Delete'];
+
+// All tools that should be imported from @jackuait/blok/tools
+const ALL_TOOLS = [...BUNDLED_TOOLS, ...INLINE_TOOLS];
 
 // Tool configuration transformations
+// Note: With named exports, tools are imported directly (e.g., { Header } from '@jackuait/blok/tools')
+// so the tool class references don't need the Blok. prefix anymore
 const TOOL_CONFIG_TRANSFORMS = [
-  // Handle class property syntax
-  { pattern: /class:\s*Header(?!Config)/g, replacement: 'class: Blok.Header' },
-  { pattern: /class:\s*Paragraph(?!Config)/g, replacement: 'class: Blok.Paragraph' },
-  // Handle standalone tool references in tools config (e.g., `paragraph: Paragraph`)
-  { pattern: /(\bheader\s*:\s*)Header(?!Config)(?=\s*[,}\n])/g, replacement: '$1Blok.Header' },
-  { pattern: /(\bparagraph\s*:\s*)Paragraph(?!Config)(?=\s*[,}\n])/g, replacement: '$1Blok.Paragraph' },
+  // Convert old Blok.Header style to direct Header reference (for existing Blok users upgrading)
+  // Block tools
+  { pattern: /class:\s*Blok\.Header(?!Config)/g, replacement: 'class: Header' },
+  { pattern: /class:\s*Blok\.Paragraph(?!Config)/g, replacement: 'class: Paragraph' },
+  { pattern: /class:\s*Blok\.List(?!Config|Item)/g, replacement: 'class: List' },
+  { pattern: /(\bheader\s*:\s*)Blok\.Header(?!Config)(?=\s*[,}\n])/g, replacement: '$1Header' },
+  { pattern: /(\bparagraph\s*:\s*)Blok\.Paragraph(?!Config)(?=\s*[,}\n])/g, replacement: '$1Paragraph' },
+  { pattern: /(\blist\s*:\s*)Blok\.List(?!Config|Item)(?=\s*[,}\n])/g, replacement: '$1List' },
+  // Inline tools
+  { pattern: /class:\s*Blok\.Bold(?!Config)/g, replacement: 'class: Bold' },
+  { pattern: /class:\s*Blok\.Italic(?!Config)/g, replacement: 'class: Italic' },
+  { pattern: /class:\s*Blok\.Link(?!Config)/g, replacement: 'class: Link' },
+  { pattern: /(\bbold\s*:\s*)Blok\.Bold(?!Config)(?=\s*[,}\n])/g, replacement: '$1Bold' },
+  { pattern: /(\bitalic\s*:\s*)Blok\.Italic(?!Config)(?=\s*[,}\n])/g, replacement: '$1Italic' },
+  { pattern: /(\blink\s*:\s*)Blok\.Link(?!Config)(?=\s*[,}\n])/g, replacement: '$1Link' },
+];
+
+// Transforms to remove internal tools configuration (Convert and Delete are now bundled)
+const INTERNAL_TOOL_REMOVAL_TRANSFORMS = [
+  // Remove convertTo/convert configuration lines (with various formats)
+  { pattern: /,?\s*convert(?:To)?\s*:\s*\{\s*class\s*:\s*(?:Blok\.)?Convert\s*\}\s*,?/g, replacement: '' },
+  { pattern: /,?\s*convert(?:To)?\s*:\s*(?:Blok\.)?Convert\s*,?/g, replacement: '' },
+  // Remove delete configuration lines
+  { pattern: /,?\s*delete\s*:\s*\{\s*class\s*:\s*(?:Blok\.)?Delete(?:Tune)?\s*\}\s*,?/g, replacement: '' },
+  { pattern: /,?\s*delete\s*:\s*(?:Blok\.)?Delete(?:Tune)?\s*,?/g, replacement: '' },
 ];
 
+// ============================================================================
+// Blok Modular Import Transformations (Strategy 5)
+// ============================================================================
+
+/**
+ * Transforms for migrating old Blok imports to the new modular structure.
+ * After Strategy 3/4, tools are in a separate entry point (@jackuait/blok/tools).
+ *
+ * Detects and transforms patterns like:
+ *   import { Blok, Header, Paragraph } from '@jackuait/blok'
+ * To:
+ *   import { Blok } from '@jackuait/blok';
+ *   import { Header, Paragraph } from '@jackuait/blok/tools';
+ */
+const BLOK_MODULAR_IMPORT_TRANSFORMS = [
+  // Transform tool imports from old @jackuait/blok to @jackuait/blok/tools
+  // These patterns match tools being imported from the main entry point
+  // The actual splitting is done in splitBlokImports() function below
+];
+
+/**
+ * Splits a combined @jackuait/blok import that contains both core exports and tools
+ * into separate imports from the correct entry points.
+ *
+ * @param {string} content - The file content
+ * @returns {{result: string, changed: boolean}} Transformed content and change flag
+ */
+function splitBlokImports(content) {
+  // Pattern to find @jackuait/blok named imports
+  const blokImportPattern = /import\s*\{\s*([^}]+)\s*\}\s*from\s*['"]@jackuait\/blok['"];?/g;
+  let result = content;
+  let changed = false;
+
+  // Collect all matches first to avoid regex state issues
+  const matches = [];
+  let match;
+  while ((match = blokImportPattern.exec(content)) !== null) {
+    matches.push({
+      fullMatch: match[0],
+      imports: match[1],
+      index: match.index,
+    });
+  }
+
+  // Process matches in reverse order to preserve indices
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const { fullMatch, imports } = matches[i];
+
+    // Parse the imports
+    const importList = imports.split(',').map(s => s.trim()).filter(s => s.length > 0);
+
+    // Separate core imports from tool imports
+    const coreImports = [];
+    const toolImports = [];
+
+    for (const imp of importList) {
+      // Handle aliased imports: "Header as MyHeader"
+      const importName = imp.split(/\s+as\s+/)[0].trim();
+
+      if (ALL_TOOLS.includes(importName)) {
+        toolImports.push(imp);
+      } else {
+        coreImports.push(imp);
+      }
+    }
+
+    // Only transform if there are tool imports mixed with core imports
+    // or if there are only tool imports (they should come from /tools)
+    if (toolImports.length > 0) {
+      let newImports = '';
+
+      if (coreImports.length > 0) {
+        newImports += `import { ${coreImports.join(', ')} } from '@jackuait/blok';\n`;
+      }
+
+      if (toolImports.length > 0) {
+        newImports += `import { ${toolImports.join(', ')} } from '@jackuait/blok/tools';`;
+      }
+
+      // Preserve trailing newline if original had one
+      if (!fullMatch.endsWith(';')) {
+        newImports = newImports.replace(/;$/, '');
+      }
+
+      result = result.replace(fullMatch, newImports);
+      changed = true;
+    }
+  }
+
+  return { result, changed };
+}
+
 // Text transformations for "EditorJS" string references
 const TEXT_TRANSFORMS = [
   // Replace exact "EditorJS" text (preserves case-sensitive matching)
@@ -321,108 +938,185 @@ function applyTransforms(content, transforms, fileName) {
 }
 
 /**
- * Ensures that Blok is properly imported when bundled tools (Blok.Header, Blok.Paragraph, etc.) are used.
- * This function checks if the content uses any Blok.* tool references and ensures there's a proper import.
+ * Ensures that bundled tools (Header, Paragraph, List) are properly imported when used.
+ * Since Blok now uses named exports, tools are imported directly.
+ *
+ * @deprecated Use ensureToolsImport instead, which imports from @jackuait/blok/tools
  *
  * Handles the following scenarios:
- * 1. No existing @jackuait/blok import -> adds `import Blok from '@jackuait/blok'`
- * 2. Named imports only (e.g., `import { BlokConfig } from '@jackuait/blok'`) -> adds Blok default import
- * 3. Default import with different name -> adds Blok to named imports
- * 4. Already has Blok default import -> no changes needed
+ * 1. Tool used without import -> adds `import { Header, Paragraph, List } from '@jackuait/blok'`
+ * 2. Existing @jackuait/blok import without tools -> adds tools to named imports
  */
 function ensureBlokImport(content) {
-  // Check if content uses any Blok.* tool (e.g., Blok.Header, Blok.Paragraph)
-  const blokToolPattern = new RegExp(`Blok\\.(${BUNDLED_TOOLS.join('|')})`, 'g');
-  const usesBlokTools = blokToolPattern.test(content);
+  // Check which bundled tools are used in the content
+  const usedTools = BUNDLED_TOOLS.filter(tool => {
+    // Match tool usage in class: Tool or tool: Tool patterns, or direct Tool references
+    const toolPattern = new RegExp(`\\b${tool}\\b`, 'g');
+    return toolPattern.test(content);
+  });
 
-  if (!usesBlokTools) {
+  if (usedTools.length === 0) {
     return { result: content, changed: false };
   }
 
-  // Check if Blok is already available as a default import
-  // Matches: import Blok from '@jackuait/blok' or import Blok, { ... } from '@jackuait/blok'
-  const hasBlokDefaultImport = /import\s+Blok\s*(?:,\s*\{[^}]*\}\s*)?from\s*['"]@jackuait\/blok['"]/.test(content);
+  // Check for existing @jackuait/blok import
+  const namedImportPattern = /import\s*\{([^}]+)\}\s*from\s*['"]@jackuait\/blok['"];?/;
+  const namedMatch = content.match(namedImportPattern);
 
-  if (hasBlokDefaultImport) {
+  let result = content;
+
+  if (namedMatch) {
+    // Check which tools are missing from the import
+    const existingImports = namedMatch[1];
+    const missingTools = usedTools.filter(tool => {
+      const toolPattern = new RegExp(`\\b${tool}\\b`);
+      return !toolPattern.test(existingImports);
+    });
+
+    if (missingTools.length > 0) {
+      // Add missing tools to existing import
+      const newImports = `${missingTools.join(', ')}, ${existingImports.trim()}`;
+      result = content.replace(
+        namedImportPattern,
+        `import { ${newImports} } from '@jackuait/blok';`
+      );
+      return { result, changed: true };
+    }
     return { result: content, changed: false };
   }
 
-  // Check for existing @jackuait/blok import patterns
-  const namedOnlyImportPattern = /import\s*\{([^}]+)\}\s*from\s*['"]@jackuait\/blok['"];?/;
-  const defaultWithNamedPattern = /import\s+(\w+)\s*,\s*\{([^}]+)\}\s*from\s*['"]@jackuait\/blok['"];?/;
-  const defaultOnlyPattern = /import\s+(\w+)\s+from\s*['"]@jackuait\/blok['"];?/;
+  // No @jackuait/blok import at all -> add new import
+  const importStatements = content.match(/^import\s+.+from\s+['"][^'"]+['"];?\s*$/gm);
+  const newImport = `import { ${usedTools.join(', ')} } from '@jackuait/blok';`;
+
+  if (importStatements && importStatements.length > 0) {
+    const lastImport = importStatements[importStatements.length - 1];
+    const lastImportIndex = content.lastIndexOf(lastImport);
+    const insertPosition = lastImportIndex + lastImport.length;
+    result =
+      content.slice(0, insertPosition) +
+      '\n' + newImport +
+      content.slice(insertPosition);
+  } else {
+    // No imports found, add at the very beginning (after shebang if present)
+    const shebangMatch = content.match(/^#!.*\n/);
+    if (shebangMatch) {
+      result = shebangMatch[0] + newImport + '\n' + content.slice(shebangMatch[0].length);
+    } else {
+      result = newImport + '\n' + content;
+    }
+  }
+
+  return { result, changed: true };
+}
+
+/**
+ * Ensures that tools are properly imported from @jackuait/blok/tools when used.
+ * This is the modern approach after Strategy 3/4 where tools are in a separate entry point.
+ *
+ * Handles the following scenarios:
+ * 1. Tool used without import -> adds `import { Header, ... } from '@jackuait/blok/tools'`
+ * 2. Existing @jackuait/blok/tools import without tools -> adds tools to named imports
+ */
+function ensureToolsImport(content) {
+  // Check which tools are used in the content
+  const usedTools = ALL_TOOLS.filter(tool => {
+    // Match tool usage in class: Tool or tool: Tool patterns, or direct Tool references
+    const toolPattern = new RegExp(`\\b${tool}\\b`, 'g');
+    return toolPattern.test(content);
+  });
+
+  if (usedTools.length === 0) {
+    return { result: content, changed: false };
+  }
+
+  // Check for existing @jackuait/blok/tools import
+  const toolsImportPattern = /import\s*\{([^}]+)\}\s*from\s*['"]@jackuait\/blok\/tools['"];?/;
+  const toolsMatch = content.match(toolsImportPattern);
+
+  // Also check for @jackuait/blok import (legacy, will be split later)
+  const mainImportPattern = /import\s*\{([^}]+)\}\s*from\s*['"]@jackuait\/blok['"];?/;
+  const mainMatch = content.match(mainImportPattern);
 
   let result = content;
 
-  // Case 1: Named imports only -> add Blok default import
-  // e.g., `import { BlokConfig } from '@jackuait/blok'` -> `import Blok, { BlokConfig } from '@jackuait/blok'`
-  const namedOnlyMatch = content.match(namedOnlyImportPattern);
-  if (namedOnlyMatch) {
-    const namedImports = namedOnlyMatch[1];
-    result = content.replace(
-      namedOnlyImportPattern,
-      `import Blok, {${namedImports}} from '@jackuait/blok';`
-    );
-    return { result, changed: true };
-  }
-
-  // Case 2: Default import with different name + named imports -> add Blok to named imports
-  // e.g., `import Editor, { BlokConfig } from '@jackuait/blok'` -> `import Editor, { Blok, BlokConfig } from '@jackuait/blok'`
-  const defaultWithNamedMatch = content.match(defaultWithNamedPattern);
-  if (defaultWithNamedMatch) {
-    const defaultName = defaultWithNamedMatch[1];
-    const namedImports = defaultWithNamedMatch[2];
-    // Check if Blok is already in named imports
-    if (!/\bBlok\b/.test(namedImports)) {
+  // Check if tools are already imported from /tools
+  if (toolsMatch) {
+    const existingToolsImports = toolsMatch[1];
+    const missingTools = usedTools.filter(tool => {
+      const toolPattern = new RegExp(`\\b${tool}\\b`);
+      return !toolPattern.test(existingToolsImports);
+    });
+
+    if (missingTools.length > 0) {
+      // Add missing tools to existing /tools import
+      const newImports = `${existingToolsImports.trim()}, ${missingTools.join(', ')}`;
       result = content.replace(
-        defaultWithNamedPattern,
-        `import ${defaultName}, { Blok, ${namedImports.trim()} } from '@jackuait/blok';`
+        toolsImportPattern,
+        `import { ${newImports} } from '@jackuait/blok/tools';`
       );
       return { result, changed: true };
     }
     return { result: content, changed: false };
   }
 
-  // Case 3: Default import only with different name -> add Blok to named imports
-  // e.g., `import Editor from '@jackuait/blok'` -> `import Editor, { Blok } from '@jackuait/blok'`
-  const defaultOnlyMatch = content.match(defaultOnlyPattern);
-  if (defaultOnlyMatch) {
-    const defaultName = defaultOnlyMatch[1];
-    if (defaultName !== 'Blok') {
+  // Check if tools are in the main import (will be split later by splitBlokImports)
+  if (mainMatch) {
+    const existingMainImports = mainMatch[1];
+    const toolsInMain = usedTools.filter(tool => {
+      const toolPattern = new RegExp(`\\b${tool}\\b`);
+      return toolPattern.test(existingMainImports);
+    });
+
+    // If all tools are already in main import, don't add duplicate
+    // They'll be moved by splitBlokImports
+    if (toolsInMain.length === usedTools.length) {
+      return { result: content, changed: false };
+    }
+
+    // Some tools missing from both imports - add them to main (will be split later)
+    const missingTools = usedTools.filter(tool => {
+      const toolPattern = new RegExp(`\\b${tool}\\b`);
+      return !toolPattern.test(existingMainImports);
+    });
+
+    if (missingTools.length > 0) {
+      const newImports = `${missingTools.join(', ')}, ${existingMainImports.trim()}`;
       result = content.replace(
-        defaultOnlyPattern,
-        `import ${defaultName}, { Blok } from '@jackuait/blok';`
+        mainImportPattern,
+        `import { ${newImports} } from '@jackuait/blok';`
       );
       return { result, changed: true };
     }
     return { result: content, changed: false };
   }
 
-  // Case 4: No @jackuait/blok import at all -> add new import at the top (after any existing imports)
-  // Find the last import statement to insert after it
+  // No @jackuait/blok or @jackuait/blok/tools import -> add new /tools import
   const importStatements = content.match(/^import\s+.+from\s+['"][^'"]+['"];?\s*$/gm);
+  const newImport = `import { ${usedTools.join(', ')} } from '@jackuait/blok/tools';`;
+
   if (importStatements && importStatements.length > 0) {
     const lastImport = importStatements[importStatements.length - 1];
     const lastImportIndex = content.lastIndexOf(lastImport);
     const insertPosition = lastImportIndex + lastImport.length;
     result =
       content.slice(0, insertPosition) +
-      "\nimport Blok from '@jackuait/blok';" +
+      '\n' + newImport +
       content.slice(insertPosition);
   } else {
     // No imports found, add at the very beginning (after shebang if present)
     const shebangMatch = content.match(/^#!.*\n/);
     if (shebangMatch) {
-      result = shebangMatch[0] + "import Blok from '@jackuait/blok';\n" + content.slice(shebangMatch[0].length);
+      result = shebangMatch[0] + newImport + '\n' + content.slice(shebangMatch[0].length);
     } else {
-      result = "import Blok from '@jackuait/blok';\n" + content;
+      result = newImport + '\n' + content;
     }
   }
 
   return { result, changed: true };
 }
 
-function transformFile(filePath, dryRun = false) {
+function transformFile(filePath, dryRun = false, useLibraryI18n = false) {
   const content = fs.readFileSync(filePath, 'utf8');
   let transformed = content;
   const allChanges = [];
@@ -488,12 +1182,28 @@ function transformFile(filePath, dryRun = false) {
     allChanges.push(...changes.map((c) => ({ ...c, category: 'tool-config' })));
   }
 
-  // Ensure Blok is imported if bundled tools are used (JS/TS only)
+  // Remove internal tools configuration (Convert and Delete are now bundled) (JS/TS only)
+  if (isJsFile) {
+    const { result, changes } = applyTransforms(transformed, INTERNAL_TOOL_REMOVAL_TRANSFORMS, filePath);
+    transformed = result;
+    allChanges.push(...changes.map((c) => ({ ...c, category: 'internal-tools-removal' })));
+  }
+
+  // Ensure tools are imported if bundled tools are used (JS/TS only)
+  if (isJsFile) {
+    const { result, changed } = ensureToolsImport(transformed);
+    if (changed) {
+      transformed = result;
+      allChanges.push({ category: 'imports', pattern: 'ensureToolsImport', count: 1, note: 'Added tools import from @jackuait/blok/tools' });
+    }
+  }
+
+  // Split combined @jackuait/blok imports into core and tools (JS/TS only)
   if (isJsFile) {
-    const { result, changed } = ensureBlokImport(transformed);
+    const { result, changed } = splitBlokImports(transformed);
     if (changed) {
       transformed = result;
-      allChanges.push({ category: 'imports', pattern: 'ensureBlokImport', count: 1, note: 'Added Blok import for bundled tools' });
+      allChanges.push({ category: 'imports', pattern: 'splitBlokImports', count: 1, note: 'Split tools into separate @jackuait/blok/tools import' });
     }
   }
 
@@ -504,6 +1214,25 @@ function transformFile(filePath, dryRun = false) {
     allChanges.push(...changes.map((c) => ({ ...c, category: 'text' })));
   }
 
+  // Apply i18n transforms (JS/TS only)
+  if (isJsFile) {
+    if (useLibraryI18n) {
+      // Remove custom messages to use Blok's built-in translations
+      const { result, changed } = removeI18nMessages(transformed);
+      if (changed) {
+        transformed = result;
+        allChanges.push({ category: 'i18n', pattern: 'removeI18nMessages', count: 1, note: 'Removed custom i18n messages to use library translations' });
+      }
+    } else {
+      // Flatten nested messages to dot-notation
+      const { result, changed } = transformI18nConfig(transformed);
+      if (changed) {
+        transformed = result;
+        allChanges.push({ category: 'i18n', pattern: 'flattenI18nMessages', count: 1, note: 'Flattened nested i18n messages to dot-notation' });
+      }
+    }
+  }
+
   const hasChanges = transformed !== content;
 
   if (hasChanges && !dryRun) {
@@ -527,7 +1256,7 @@ function updatePackageJson(packageJsonPath, dryRun = false) {
   const changes = [];
 
   // Track dependencies to remove
-  const depsToRemove = ['@editorjs/editorjs', '@editorjs/header', '@editorjs/paragraph'];
+  const depsToRemove = ['@editorjs/editorjs', '@editorjs/header', '@editorjs/paragraph', '@editorjs/list'];
   const devDepsToRemove = [...depsToRemove];
 
   // Check and update dependencies
@@ -580,9 +1309,10 @@ Arguments:
   path          Directory or file to transform (default: current directory)
 
 Options:
-  --dry-run     Show changes without modifying files
-  --verbose     Show detailed output for each file
-  --help        Show this help message
+  --dry-run           Show changes without modifying files
+  --verbose           Show detailed output for each file
+  --use-library-i18n  Remove custom i18n messages and use Blok's built-in translations
+  --help              Show this help message
 
 Examples:
   npx -p @jackuait/blok migrate-from-editorjs ./src
@@ -590,17 +1320,24 @@ Examples:
   npx -p @jackuait/blok migrate-from-editorjs . --verbose
 
 What this codemod does:
-  • Transforms EditorJS imports to Blok imports
+
+  EditorJS Migration:
+  • Transforms EditorJS imports to Blok named imports:
+    - import EditorJS from '@editorjs/editorjs' → import { Blok } from '@jackuait/blok'
+    - import Editor from '@editorjs/editorjs' → import { Blok as Editor } from '@jackuait/blok'
+  • Updates bundled tool imports (Header, Paragraph, List):
+    - import Header from '@editorjs/header' → import { Header } from '@jackuait/blok/tools'
+    - import List from '@editorjs/list' → import { List } from '@jackuait/blok/tools'
   • Updates type names (EditorConfig → BlokConfig)
   • Replaces 'new EditorJS()' with 'new Blok()'
   • Converts CSS class selectors to data attributes:
     - .codex-editor* → [data-blok-editor], [data-blok-redactor], etc.
     - .ce-block* → [data-blok-element], [data-blok-selected], etc.
     - .ce-toolbar* → [data-blok-toolbar], [data-blok-settings-toggler], etc.
-    - .ce-toolbox* → [data-blok-toolbox], etc.
+    - .ce-toolbox* → [data-blok-toolbox], [data-blok-toolbox-opened], etc.
     - .ce-inline-toolbar, .ce-inline-tool* → [data-blok-testid="inline-*"]
-    - .ce-popover* → [data-blok-popover], [data-blok-popover-container], etc.
-    - .ce-popover-item* → [data-blok-testid="popover-item*"], [data-blok-confirmation], etc.
+    - .ce-popover* → [data-blok-popover], [data-blok-popover-opened], [data-blok-popover-container], etc.
+    - .ce-popover-item* → [data-blok-testid="popover-item*"], [data-blok-popover-item-confirmation], etc.
     - .ce-paragraph, .ce-header → [data-blok-tool="paragraph|header"]
     - .cdx-list* → [data-blok-list], [data-blok-list-item], etc.
     - .cdx-button, .cdx-input, .cdx-loader → [data-blok-button], etc.
@@ -608,8 +1345,32 @@ What this codemod does:
   • Updates data attributes (data-id → data-blok-id)
   • Changes default holder from 'editorjs' to 'blok'
   • Updates package.json dependencies
-  • Converts bundled tool imports (Header, Paragraph)
-  • Ensures Blok is imported when using bundled tools (Blok.Header, etc.)
+  • Transforms nested i18n messages to flat dot-notation format with camelCase keys:
+    - { ui: { toolbar: { Add: "..." } } } → { "ui.toolbar.add": "..." }
+    - { toolNames: { "Nothing found": "..." } } → { "toolNames.nothingFound": "..." }
+  • Maps changed i18n keys to their Blok equivalents (camelCase):
+    - "Click to tune" → "clickToOpenMenu"
+    - "or drag to move" → "dragToMove"
+    - "Add" (toolbar) → "clickToAddBelow"
+    - "Filter" (popover) → "search"
+    - "Ordered List" → "numberedList"
+    - "Unordered List" → "bulletedList"
+  • Removes obsolete keys (moveUp/moveDown replaced with drag)
+
+  Old Blok → Modular Blok Migration:
+  • Splits combined imports into core and tools:
+    - import { Blok, Header } from '@jackuait/blok'
+    → import { Blok } from '@jackuait/blok';
+      import { Header } from '@jackuait/blok/tools';
+  • Transforms static property access to direct references:
+    - Blok.Header → Header (with import added)
+    - Blok.Paragraph → Paragraph
+    - Blok.List → List
+    - Blok.Bold, Blok.Italic, Blok.Link → Bold, Italic, Link
+  • Removes internal tools configuration (Convert and Delete are now bundled with core):
+    - convertTo: { class: Convert } → removed (automatically available)
+    - delete: { class: Delete } → removed (automatically available)
+  • Ensures tools are imported from @jackuait/blok/tools when used
 
 Note: After running, you may need to manually:
   • Update any custom tool implementations
@@ -624,6 +1385,7 @@ function main() {
   // Parse arguments
   const dryRun = args.includes('--dry-run');
   const verbose = args.includes('--verbose');
+  const useLibraryI18n = args.includes('--use-library-i18n');
   const help = args.includes('--help') || args.includes('-h');
 
   global.isVerbose = verbose;
@@ -666,7 +1428,7 @@ function main() {
 
   // Process each file
   files.forEach((filePath) => {
-    const result = transformFile(filePath, dryRun);
+    const result = transformFile(filePath, dryRun, useLibraryI18n);
 
     if (result.hasChanges) {
       stats.filesModified++;
@@ -732,7 +1494,20 @@ module.exports = {
   updatePackageJson,
   applyTransforms,
   ensureBlokImport,
+  ensureToolsImport,
+  splitBlokImports,
+  normalizeKey,
+  flattenI18nDictionary,
+  transformI18nConfig,
+  removeI18nMessages,
+  parseObjectLiteral,
+  findMatchingBrace,
+  objectToString,
+  I18N_KEY_MAPPINGS,
   BUNDLED_TOOLS,
+  INLINE_TOOLS,
+  INTERNAL_TOOLS,
+  ALL_TOOLS,
   IMPORT_TRANSFORMS,
   TYPE_TRANSFORMS,
   CLASS_NAME_TRANSFORMS,
@@ -741,5 +1516,6 @@ module.exports = {
   SELECTOR_TRANSFORMS,
   HOLDER_TRANSFORMS,
   TOOL_CONFIG_TRANSFORMS,
+  INTERNAL_TOOL_REMOVAL_TRANSFORMS,
   TEXT_TRANSFORMS,
 };