@principal-ade/industry-themed-mdx-editor 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -4,6 +4,8 @@ export { ThemedMDXEditorWithProvider } from './src/components/ThemedMDXEditorWit
 export type { ThemedMDXEditorWithProviderProps } from './src/components/ThemedMDXEditorWithProvider';
 export { useThemedMDXEditor } from './src/hooks/useThemedMDXEditor';
 export { createCodeMirrorTheme, createAutoCodeMirrorTheme } from './src/utils/codeMirrorTheme';
+export { preprocessMDX, defaultPreprocessRules, mdxAutoFix, lessThanDigitTransformer, greaterThanDigitTransformer, invalidTagNamesTransformer, defaultTransformers, allTransformers, } from './src/plugins/mdx-auto-fix';
+export type { PreprocessRule, MDXAutoFixOptions, Transformer, TransformerContext, TransformerStats, TransformerTestCase, } from './src/plugins/mdx-auto-fix';
 export type { Theme } from '@a24z/industry-theme';
 export type { MDXEditorMethods, MDXEditorProps } from '@mdxeditor/editor';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAE9F,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAC3F,YAAY,EAAE,gCAAgC,EAAE,MAAM,8CAA8C,CAAC;AAGrG,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAG/F,YAAY,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAGlD,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAE9F,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAC3F,YAAY,EAAE,gCAAgC,EAAE,MAAM,8CAA8C,CAAC;AAGrG,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAG/F,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,UAAU,EACV,wBAAwB,EACxB,2BAA2B,EAC3B,0BAA0B,EAC1B,mBAAmB,EACnB,eAAe,GAChB,MAAM,4BAA4B,CAAC;AAEpC,YAAY,EACV,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,4BAA4B,CAAC;AAGpC,YAAY,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAGlD,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.mjs

@@ -3,6 +3,499 @@ import {
   MDXEditor
 } from "@mdxeditor/editor";
 import "@mdxeditor/editor/style.css";
+
+// src/plugins/mdx-auto-fix/preprocessor.ts
+var defaultPreprocessRules = [
+  {
+    name: "normalize-code-block-language",
+    description: "Normalize unknown code block language identifiers",
+    pattern: /```(argdown|N\/A|n\/a)\n/gi,
+    replacement: (_match, lang) => {
+      const langLower = lang.toLowerCase();
+      if (langLower === "n/a") {
+        return "```text\n";
+      }
+      if (langLower === "argdown") {
+        return "```markdown\n";
+      }
+      return "```text\n";
+    }
+  },
+  {
+    name: "less-than-digit",
+    description: "Escape < followed by digit",
+    pattern: /<(?=\d)/g,
+    replacement: "&lt;"
+  },
+  {
+    name: "less-than-space-digit",
+    description: "Escape < followed by space and digit",
+    pattern: /<(\s+)(?=\d)/g,
+    replacement: (_match, spaces) => `&lt;${spaces}`
+  },
+  {
+    name: "greater-than-digit",
+    description: "Escape > followed by digit",
+    pattern: /(?<![-\w])>(?=\s?\d)/g,
+    replacement: "&gt;"
+  },
+  {
+    name: "invalid-tag-opening",
+    description: "Escape invalid opening tags starting with digit",
+    pattern: /<(\/?(?:\d[^>\s]*))/g,
+    replacement: (_match, tagContent) => `&lt;${tagContent}`
+  },
+  {
+    name: "numeric-only-tag",
+    description: "Escape tags that are only numbers",
+    pattern: /<(\d+)>/g,
+    replacement: (_match, number) => `&lt;${number}>`
+  }
+];
+function preserveCode(markdown, transform) {
+  const parts = [];
+  const codeRegex = /(```[\s\S]*?```|`[^`\n]+`)/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = codeRegex.exec(markdown)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push({
+        type: "text",
+        content: markdown.slice(lastIndex, match.index)
+      });
+    }
+    parts.push({
+      type: "code",
+      content: match[0]
+    });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < markdown.length) {
+    parts.push({
+      type: "text",
+      content: markdown.slice(lastIndex)
+    });
+  }
+  return parts.map((part) => part.type === "code" ? part.content : transform(part.content)).join("");
+}
+function preprocessMDX(markdown, options = {}) {
+  const {
+    rules = defaultPreprocessRules,
+    enable,
+    disable,
+    preserveCodeBlocks = true,
+    onStats,
+    debug = false
+  } = options;
+  let activeRules = rules;
+  if (enable && enable.length > 0) {
+    activeRules = rules.filter((r) => enable.includes(r.name));
+  }
+  if (disable && disable.length > 0) {
+    activeRules = activeRules.filter((r) => !disable.includes(r.name));
+  }
+  if (debug) {
+    console.log("[mdx-auto-fix] Active preprocessing rules:", activeRules.map((r) => r.name));
+  }
+  const stats = {
+    totalFixes: 0,
+    byTransformer: {}
+  };
+  let result = markdown;
+  const codeBlockLangRule = activeRules.find((r) => r.name === "normalize-code-block-language");
+  if (codeBlockLangRule) {
+    let fixCount = 0;
+    if (typeof codeBlockLangRule.replacement === "function") {
+      result = result.replace(codeBlockLangRule.pattern, (...args) => {
+        fixCount++;
+        return codeBlockLangRule.replacement(...args);
+      });
+    } else {
+      result = result.replace(codeBlockLangRule.pattern, () => {
+        fixCount++;
+        return codeBlockLangRule.replacement;
+      });
+    }
+    if (fixCount > 0) {
+      stats.byTransformer[codeBlockLangRule.name] = fixCount;
+      stats.totalFixes += fixCount;
+      if (debug) {
+        console.log(`[mdx-auto-fix] ${codeBlockLangRule.name}: ${fixCount} fixes`);
+      }
+    }
+  }
+  const otherRules = activeRules.filter((r) => r.name !== "normalize-code-block-language");
+  const transform = (text) => {
+    let transformed = text;
+    for (const rule of otherRules) {
+      let fixCount = 0;
+      if (typeof rule.replacement === "function") {
+        transformed = transformed.replace(rule.pattern, (...args) => {
+          fixCount++;
+          return rule.replacement(...args);
+        });
+      } else {
+        transformed = transformed.replace(rule.pattern, () => {
+          fixCount++;
+          return rule.replacement;
+        });
+      }
+      if (fixCount > 0) {
+        stats.byTransformer[rule.name] = (stats.byTransformer[rule.name] || 0) + fixCount;
+        stats.totalFixes += fixCount;
+        if (debug) {
+          console.log(`[mdx-auto-fix] ${rule.name}: ${fixCount} fixes`);
+        }
+      }
+    }
+    return transformed;
+  };
+  result = preserveCodeBlocks ? preserveCode(result, transform) : transform(result);
+  if (onStats && stats.totalFixes > 0) {
+    onStats(stats);
+  }
+  if (debug && stats.totalFixes > 0) {
+    console.log(`[mdx-auto-fix] Total preprocessing fixes: ${stats.totalFixes}`);
+  }
+  return result;
+}
+
+// src/plugins/mdx-auto-fix/transformers/less-than-digit.ts
+import { visit } from "unist-util-visit";
+var lessThanDigitTransformer = {
+  name: "less-than-digit",
+  description: 'Escapes < when followed by a digit (e.g., "<5 minutes" \u2192 "&lt;5 minutes")',
+  defaultEnabled: true,
+  transform: (context) => {
+    let fixCount = 0;
+    visit(context.tree, "text", (node) => {
+      node.value = node.value.replace(/<(?=\d)/g, () => {
+        fixCount++;
+        return "&lt;";
+      });
+      node.value = node.value.replace(/<\s+(?=\d)/g, (match) => {
+        fixCount++;
+        return match.replace("<", "&lt;");
+      });
+    });
+    context.stats.byTransformer[lessThanDigitTransformer.name] = fixCount;
+    context.stats.totalFixes += fixCount;
+  },
+  testCases: [
+    {
+      description: "Basic less-than with digit",
+      input: "- <5 minutes to complete",
+      expected: "- &lt;5 minutes to complete",
+      shouldFix: "Should escape < immediately followed by digit"
+    },
+    {
+      description: "Less-than with space and digit",
+      input: "- < 5 minutes to complete",
+      expected: "- &lt; 5 minutes to complete",
+      shouldFix: "Should escape < followed by space and digit"
+    },
+    {
+      description: "Multiple occurrences",
+      input: "Metrics: <5ms latency, <10MB memory, <2% error rate",
+      expected: "Metrics: &lt;5ms latency, &lt;10MB memory, &lt;2% error rate",
+      shouldFix: "Should fix all occurrences in a line"
+    },
+    {
+      description: "Percentage comparisons",
+      input: "- <5% configuration error rate",
+      expected: "- &lt;5% configuration error rate",
+      shouldFix: "Should fix percentage comparisons"
+    },
+    {
+      description: "Size comparisons",
+      input: "Bundle size: <20MB",
+      expected: "Bundle size: &lt;20MB",
+      shouldFix: "Should fix size comparisons"
+    },
+    {
+      description: "Time estimates in lists",
+      input: `**Target**:
+- 90%+ setup completion rate
+- <5 minutes to first workflow
+- <5% configuration error rate`,
+      expected: `**Target**:
+- 90%+ setup completion rate
+- &lt;5 minutes to first workflow
+- &lt;5% configuration error rate`,
+      shouldFix: "Should fix real-world documentation patterns"
+    },
+    {
+      description: "Should not affect valid JSX",
+      input: "<Component prop={5} />",
+      expected: "<Component prop={5} />",
+      shouldFix: "Should preserve valid JSX tags"
+    }
+  ]
+};
+
+// src/plugins/mdx-auto-fix/transformers/greater-than-digit.ts
+import { visit as visit2 } from "unist-util-visit";
+var greaterThanDigitTransformer = {
+  name: "greater-than-digit",
+  description: 'Escapes > when followed by a digit (e.g., ">5 users" \u2192 "&gt;5 users")',
+  defaultEnabled: true,
+  transform: (context) => {
+    let fixCount = 0;
+    visit2(context.tree, "text", (node) => {
+      node.value = node.value.replace(/(?<![-\w])>(?=\s?\d)/g, () => {
+        fixCount++;
+        return "&gt;";
+      });
+    });
+    context.stats.byTransformer[greaterThanDigitTransformer.name] = fixCount;
+    context.stats.totalFixes += fixCount;
+  },
+  testCases: [
+    {
+      description: "Basic greater-than with digit",
+      input: "- >90% completion rate",
+      expected: "- &gt;90% completion rate",
+      shouldFix: "Should escape > immediately followed by digit"
+    },
+    {
+      description: "Greater-than with space and digit",
+      input: "- > 5 users online",
+      expected: "- &gt; 5 users online",
+      shouldFix: "Should escape > followed by space and digit"
+    },
+    {
+      description: "Multiple occurrences",
+      input: "Requirements: >5GB RAM, >10 cores, >100GB storage",
+      expected: "Requirements: &gt;5GB RAM, &gt;10 cores, &gt;100GB storage",
+      shouldFix: "Should fix all occurrences"
+    },
+    {
+      description: "Should not affect valid JSX closing tags",
+      input: "<Component>content</Component>",
+      expected: "<Component>content</Component>",
+      shouldFix: "Should preserve valid JSX closing tags"
+    }
+  ]
+};
+
+// src/plugins/mdx-auto-fix/transformers/invalid-tag-names.ts
+import { visit as visit3 } from "unist-util-visit";
+var invalidTagNamesTransformer = {
+  name: "invalid-tag-names",
+  description: 'Escapes tags with invalid names (e.g., "<5Column>" \u2192 "&lt;5Column>")',
+  defaultEnabled: true,
+  transform: (context) => {
+    let fixCount = 0;
+    visit3(context.tree, "text", (node) => {
+      node.value = node.value.replace(/<\/?(\d[^>\s]*)/g, (match) => {
+        fixCount++;
+        return match.replace("<", "&lt;");
+      });
+      node.value = node.value.replace(/<(\d+)>/g, (match) => {
+        fixCount++;
+        return match.replace("<", "&lt;");
+      });
+    });
+    context.stats.byTransformer[invalidTagNamesTransformer.name] = fixCount;
+    context.stats.totalFixes += fixCount;
+  },
+  testCases: [
+    {
+      description: "Tag starting with number",
+      input: "<5Column>Content</5Column>",
+      expected: "&lt;5Column>Content&lt;/5Column>",
+      shouldFix: "Should escape opening and closing tags that start with numbers"
+    },
+    {
+      description: "Numeric-only tag",
+      input: "<123>",
+      expected: "&lt;123>",
+      shouldFix: "Should escape tags that are only numbers"
+    },
+    {
+      description: "Tag with number prefix",
+      input: '<3DModel src="path" />',
+      expected: '&lt;3DModel src="path" />',
+      shouldFix: "Should escape self-closing tags that start with numbers"
+    },
+    {
+      description: "Should preserve valid tags",
+      input: "<Component5>Content</Component5>",
+      expected: "<Component5>Content</Component5>",
+      shouldFix: "Should not affect tags that start with valid characters"
+    }
+  ]
+};
+
+// src/plugins/mdx-auto-fix/transformers/code-block-language.ts
+import { visit as visit4 } from "unist-util-visit";
+var LANGUAGE_MAP = {
+  "N/A": "text",
+  "n/a": "text",
+  "argdown": "markdown"
+  // Map argdown to markdown for better syntax highlighting
+  // Add more mappings as needed
+};
+var KNOWN_LANGUAGES = /* @__PURE__ */ new Set([
+  "javascript",
+  "js",
+  "typescript",
+  "ts",
+  "jsx",
+  "tsx",
+  "python",
+  "py",
+  "java",
+  "c",
+  "cpp",
+  "csharp",
+  "cs",
+  "html",
+  "css",
+  "scss",
+  "sass",
+  "less",
+  "json",
+  "yaml",
+  "yml",
+  "xml",
+  "toml",
+  "bash",
+  "sh",
+  "shell",
+  "powershell",
+  "sql",
+  "graphql",
+  "markdown",
+  "md",
+  "rust",
+  "go",
+  "ruby",
+  "php",
+  "swift",
+  "kotlin",
+  "dart",
+  "r",
+  "matlab",
+  "diff",
+  "text",
+  "plaintext"
+]);
+var codeBlockLanguageTransformer = {
+  name: "code-block-language",
+  description: "Normalizes unrecognized code block language identifiers to safe alternatives",
+  defaultEnabled: true,
+  transform: (context) => {
+    let fixCount = 0;
+    visit4(context.tree, "code", (node) => {
+      const lang = node.lang?.toLowerCase().trim();
+      if (!lang) {
+        node.lang = "text";
+        fixCount++;
+        return;
+      }
+      if (LANGUAGE_MAP[lang]) {
+        node.lang = LANGUAGE_MAP[lang];
+        fixCount++;
+        return;
+      }
+      if (!KNOWN_LANGUAGES.has(lang)) {
+      }
+    });
+    context.stats.byTransformer[codeBlockLanguageTransformer.name] = fixCount;
+    context.stats.totalFixes += fixCount;
+  },
+  testCases: [
+    {
+      description: "Code block with N/A language",
+      input: "```N/A\ncode here\n```",
+      expected: "```text\ncode here\n```",
+      shouldFix: "Should convert N/A to text"
+    },
+    {
+      description: "Code block with argdown language",
+      input: "```argdown\n[Claim]: Statement\n```",
+      expected: "```markdown\n[Claim]: Statement\n```",
+      shouldFix: "Should convert argdown to markdown"
+    },
+    {
+      description: "Code block without language",
+      input: "```\ncode here\n```",
+      expected: "```text\ncode here\n```",
+      shouldFix: "Should add text language to blocks without one"
+    },
+    {
+      description: "Should preserve known languages",
+      input: "```javascript\nconst x = 1;\n```",
+      expected: "```javascript\nconst x = 1;\n```",
+      shouldFix: "Should not modify known languages"
+    }
+  ]
+};
+
+// src/plugins/mdx-auto-fix/transformers/index.ts
+var defaultTransformers = [
+  lessThanDigitTransformer,
+  greaterThanDigitTransformer,
+  invalidTagNamesTransformer,
+  codeBlockLanguageTransformer
+];
+var allTransformers = [
+  lessThanDigitTransformer,
+  greaterThanDigitTransformer,
+  invalidTagNamesTransformer,
+  codeBlockLanguageTransformer
+];
+
+// src/plugins/mdx-auto-fix/plugin.ts
+var mdxAutoFix = (options = {}) => {
+  const {
+    transformers = defaultTransformers,
+    enable,
+    disable,
+    onStats,
+    debug = false
+  } = options;
+  return (tree) => {
+    const stats = {
+      totalFixes: 0,
+      byTransformer: {}
+    };
+    let activeTransformers = transformers.filter((t) => t.defaultEnabled);
+    if (enable && enable.length > 0) {
+      activeTransformers = transformers.filter((t) => enable.includes(t.name));
+    }
+    if (disable && disable.length > 0) {
+      activeTransformers = activeTransformers.filter((t) => !disable.includes(t.name));
+    }
+    if (debug) {
+      console.log("[mdx-auto-fix] Active transformers:", activeTransformers.map((t) => t.name));
+    }
+    for (const transformer of activeTransformers) {
+      try {
+        transformer.transform({
+          tree,
+          stats
+        });
+        if (debug && stats.byTransformer[transformer.name] > 0) {
+          console.log(
+            `[mdx-auto-fix] ${transformer.name}: ${stats.byTransformer[transformer.name]} fixes`
+          );
+        }
+      } catch (error) {
+        console.error(`[mdx-auto-fix] Error in transformer "${transformer.name}":`, error);
+      }
+    }
+    if (debug && stats.totalFixes > 0) {
+      console.log(`[mdx-auto-fix] Total fixes applied: ${stats.totalFixes}`);
+    }
+    if (onStats && stats.totalFixes > 0) {
+      onStats(stats);
+    }
+  };
+};
+
+// src/components/ThemedMDXEditor.tsx
 import {
   useCallback,
   useEffect,
@@ -91,6 +584,7 @@ var ThemedMDXEditor = forwardRef((props, ref) => {
     containerStyle = {},
     showLoadingState = false,
     documentPadding,
+    autoFixMDX = true,
     markdown: controlledMarkdown,
     onChange: externalOnChange,
     ...restEditorProps
@@ -110,6 +604,14 @@ var ThemedMDXEditor = forwardRef((props, ref) => {
   const [savedValue, setSavedValue] = useState(() => computeInitialValue());
   const [isDirty, setIsDirty] = useState(false);
   const currentValue = isControlled ? controlledMarkdown ?? "" : internalValue;
+  const processedMarkdown = useMemo(() => {
+    if (!autoFixMDX) {
+      return currentValue;
+    }
+    return preprocessMDX(currentValue, {
+      preserveCodeBlocks: true
+    });
+  }, [currentValue, autoFixMDX]);
   useEffect(() => {
     setIsMounted(true);
     if (showLoadingState) {
@@ -332,7 +834,7 @@ var ThemedMDXEditor = forwardRef((props, ref) => {
           MDXEditor,
           {
             ref: editorRef,
-            markdown: currentValue,
+            markdown: processedMarkdown,
             onChange: handleChange,
             contentEditableClassName: "mdx-editor-content",
             ...restEditorProps
@@ -579,7 +1081,15 @@ function useThemedMDXEditor() {
 export {
   ThemedMDXEditor,
   ThemedMDXEditorWithProvider,
+  allTransformers,
   createAutoCodeMirrorTheme,
   createCodeMirrorTheme,
+  defaultPreprocessRules,
+  defaultTransformers,
+  greaterThanDigitTransformer,
+  invalidTagNamesTransformer,
+  lessThanDigitTransformer,
+  mdxAutoFix,
+  preprocessMDX,
   useThemedMDXEditor
 };

package/dist/src/components/ThemedMDXEditor.d.ts

@@ -24,6 +24,7 @@ export interface ThemedMDXEditorProps extends Omit<MDXEditorProps, 'className' |
     containerStyle?: React.CSSProperties;
     showLoadingState?: boolean;
     documentPadding?: DocumentPadding;
+    autoFixMDX?: boolean;
 }
 export declare const ThemedMDXEditor: React.ForwardRefExoticComponent<ThemedMDXEditorProps & React.RefAttributes<MDXEditorMethods>>;
 //# sourceMappingURL=ThemedMDXEditor.d.ts.map

package/dist/src/components/ThemedMDXEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThemedMDXEditor.d.ts","sourceRoot":"","sources":["../../../src/components/ThemedMDXEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,6BAA6B,CAAC;AACrC,OAAO,gCAAgC,CAAC;AACxC,OAAO,KAQN,MAAM,OAAO,CAAC;AAMf,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,MAAM,GACN;IACE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,GACD,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,MAAM,CAAC;AAEX,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,0BAA0B,CAAC;IAI1G,KAAK,EAAE,KAAK,CAAC;IAIb,gBAAgB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAInC,YAAY,CAAC,EAAE,MAAM,CAAC;IAItB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAIjF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAIlB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAI7B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAK3C,aAAa,CAAC,EAAE,OAAO,CAAC;IAIxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAI5B,cAAc,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAIrC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAoB3B,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAuFD,eAAO,MAAM,eAAe,+FAiW1B,CAAC"}
+{"version":3,"file":"ThemedMDXEditor.d.ts","sourceRoot":"","sources":["../../../src/components/ThemedMDXEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,6BAA6B,CAAC;AACrC,OAAO,gCAAgC,CAAC;AAExC,OAAO,KAQN,MAAM,OAAO,CAAC;AAMf,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,MAAM,GACN;IACE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,GACD,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,MAAM,CAAC;AAEX,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,0BAA0B,CAAC;IAI1G,KAAK,EAAE,KAAK,CAAC;IAIb,gBAAgB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAInC,YAAY,CAAC,EAAE,MAAM,CAAC;IAItB,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAIjF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAIlB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAI7B,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAK3C,aAAa,CAAC,EAAE,OAAO,CAAC;IAIxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAI5B,cAAc,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAIrC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAoB3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAelC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAuFD,eAAO,MAAM,eAAe,+FA4W1B,CAAC"}

package/dist/src/plugins/mdx-auto-fix/index.d.ts

@@ -0,0 +1,7 @@
+export { preprocessMDX, defaultPreprocessRules } from './preprocessor';
+export type { PreprocessRule } from './preprocessor';
+export { mdxAutoFix } from './plugin';
+export type { MDXAutoFixOptions } from './plugin';
+export type { Transformer, TransformerContext, TransformerStats, TransformerTestCase, } from './types';
+export { lessThanDigitTransformer, greaterThanDigitTransformer, invalidTagNamesTransformer, defaultTransformers, allTransformers, } from './transformers';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/plugins/mdx-auto-fix/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/mdx-auto-fix/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACvE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAGlD,YAAY,EACV,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,wBAAwB,EACxB,2BAA2B,EAC3B,0BAA0B,EAC1B,mBAAmB,EACnB,eAAe,GAChB,MAAM,gBAAgB,CAAC"}

package/dist/src/plugins/mdx-auto-fix/plugin.d.ts

@@ -0,0 +1,12 @@
+import type { Root } from 'mdast';
+import type { Transformer, TransformerStats } from './types';
+import type { Plugin } from 'unified';
+export interface MDXAutoFixOptions {
+    transformers?: Transformer[];
+    enable?: string[];
+    disable?: string[];
+    onStats?: (stats: TransformerStats) => void;
+    debug?: boolean;
+}
+export declare const mdxAutoFix: Plugin<[MDXAutoFixOptions?], Root>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/src/plugins/mdx-auto-fix/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../src/plugins/mdx-auto-fix/plugin.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAClC,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAKtC,MAAM,WAAW,iBAAiB;IAIhC,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAK7B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAKlB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAKnB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAK5C,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAKD,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,CAAC,iBAAiB,CAAC,CAAC,EAAE,IAAI,CA2DzD,CAAC"}

package/dist/src/plugins/mdx-auto-fix/preprocessor.d.ts

@@ -0,0 +1,17 @@
+import type { TransformerStats } from './types';
+export interface PreprocessRule {
+    name: string;
+    description: string;
+    pattern: RegExp;
+    replacement: string | ((match: string, ...args: any[]) => string);
+}
+export declare const defaultPreprocessRules: PreprocessRule[];
+export declare function preprocessMDX(markdown: string, options?: {
+    rules?: PreprocessRule[];
+    enable?: string[];
+    disable?: string[];
+    preserveCodeBlocks?: boolean;
+    onStats?: (stats: TransformerStats) => void;
+    debug?: boolean;
+}): string;
+//# sourceMappingURL=preprocessor.d.ts.map

package/dist/src/plugins/mdx-auto-fix/preprocessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preprocessor.d.ts","sourceRoot":"","sources":["../../../../src/plugins/mdx-auto-fix/preprocessor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAKhD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,MAAM,CAAC,CAAC;CACnE;AAKD,eAAO,MAAM,sBAAsB,EAAE,cAAc,EA8ClD,CAAC;AAgDF,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;IACP,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;CACZ,GACL,MAAM,CAyGR"}

package/dist/src/plugins/mdx-auto-fix/transformers/code-block-language.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer } from '../types';
+export declare const codeBlockLanguageTransformer: Transformer;
+//# sourceMappingURL=code-block-language.d.ts.map

package/dist/src/plugins/mdx-auto-fix/transformers/code-block-language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-block-language.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/mdx-auto-fix/transformers/code-block-language.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,UAAU,CAAC;AA8BhE,eAAO,MAAM,4BAA4B,EAAE,WA+D1C,CAAC"}

package/dist/src/plugins/mdx-auto-fix/transformers/greater-than-digit.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer } from '../types';
+export declare const greaterThanDigitTransformer: Transformer;
+//# sourceMappingURL=greater-than-digit.d.ts.map

package/dist/src/plugins/mdx-auto-fix/transformers/greater-than-digit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greater-than-digit.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/mdx-auto-fix/transformers/greater-than-digit.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,UAAU,CAAC;AAKhE,eAAO,MAAM,2BAA2B,EAAE,WA+CzC,CAAC"}

package/dist/src/plugins/mdx-auto-fix/transformers/index.d.ts

@@ -0,0 +1,8 @@
+export { lessThanDigitTransformer } from './less-than-digit';
+export { greaterThanDigitTransformer } from './greater-than-digit';
+export { invalidTagNamesTransformer } from './invalid-tag-names';
+export { codeBlockLanguageTransformer } from './code-block-language';
+import type { Transformer } from '../types';
+export declare const defaultTransformers: Transformer[];
+export declare const allTransformers: Transformer[];
+//# sourceMappingURL=index.d.ts.map

package/dist/src/plugins/mdx-auto-fix/transformers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/mdx-auto-fix/transformers/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,4BAA4B,EAAE,MAAM,uBAAuB,CAAC;AAMrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAK5C,eAAO,MAAM,mBAAmB,EAAE,WAAW,EAK5C,CAAC;AAKF,eAAO,MAAM,eAAe,EAAE,WAAW,EAKxC,CAAC"}

package/dist/src/plugins/mdx-auto-fix/transformers/invalid-tag-names.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer } from '../types';
+export declare const invalidTagNamesTransformer: Transformer;
+//# sourceMappingURL=invalid-tag-names.d.ts.map

package/dist/src/plugins/mdx-auto-fix/transformers/invalid-tag-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-tag-names.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/mdx-auto-fix/transformers/invalid-tag-names.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,UAAU,CAAC;AAKhE,eAAO,MAAM,0BAA0B,EAAE,WAqDxC,CAAC"}

package/dist/src/plugins/mdx-auto-fix/transformers/less-than-digit.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer } from '../types';
+export declare const lessThanDigitTransformer: Transformer;
+//# sourceMappingURL=less-than-digit.d.ts.map

package/dist/src/plugins/mdx-auto-fix/transformers/less-than-digit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-than-digit.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/mdx-auto-fix/transformers/less-than-digit.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,UAAU,CAAC;AAKhE,eAAO,MAAM,wBAAwB,EAAE,WA4EtC,CAAC"}

package/dist/src/plugins/mdx-auto-fix/types.d.ts

@@ -0,0 +1,24 @@
+import type { Root } from 'mdast';
+export interface TransformerContext {
+    tree: Root;
+    originalMarkdown?: string;
+    stats: TransformerStats;
+}
+export interface TransformerStats {
+    totalFixes: number;
+    byTransformer: Record<string, number>;
+}
+export interface Transformer {
+    name: string;
+    description: string;
+    defaultEnabled: boolean;
+    transform: (context: TransformerContext) => void;
+    testCases?: TransformerTestCase[];
+}
+export interface TransformerTestCase {
+    description: string;
+    input: string;
+    expected: string;
+    shouldFix?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/plugins/mdx-auto-fix/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/plugins/mdx-auto-fix/types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC;AAKlC,MAAM,WAAW,kBAAkB;IAIjC,IAAI,EAAE,IAAI,CAAC;IAKX,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAK1B,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAKD,MAAM,WAAW,gBAAgB;IAI/B,UAAU,EAAE,MAAM,CAAC;IAKnB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAKD,MAAM,WAAW,WAAW;IAI1B,IAAI,EAAE,MAAM,CAAC;IAKb,WAAW,EAAE,MAAM,CAAC;IAKpB,cAAc,EAAE,OAAO,CAAC;IAKxB,SAAS,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAKjD,SAAS,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACnC;AAKD,MAAM,WAAW,mBAAmB;IAIlC,WAAW,EAAE,MAAM,CAAC;IAKpB,KAAK,EAAE,MAAM,CAAC;IAKd,QAAQ,EAAE,MAAM,CAAC;IAKjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principal-ade/industry-themed-mdx-editor",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Industry-themed MDX editor wrapper with integrated theming",
   "type": "module",
   "main": "dist/index.mjs",
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "build": "bun run clean && bun run build:esm && bun run build:types && bun run build:styles",
-    "build:esm": "NODE_ENV=production bun build ./index.ts --outfile ./dist/index.mjs --format esm --target browser --external react --external react-dom --external @mdxeditor/editor --external @a24z/industry-theme",
+    "build:esm": "esbuild index.ts --bundle --format=esm --outfile=dist/index.mjs --external:react --external:react-dom --external:@mdxeditor/editor --external:@a24z/industry-theme --external:remark --external:remark-mdx --external:unist-util-visit --external:mdast --external:@codemirror/state --external:@codemirror/view",
     "build:types": "tsc --project tsconfig.build.json --emitDeclarationOnly --declaration --declarationMap",
     "build:styles": "cp src/styles/mdx-editor-theme.css dist/styles.css",
     "dev": "bun run build --watch",
@@ -75,6 +75,7 @@
     "@storybook/addon-webpack5-compiler-swc": "^4.0.1",
     "@storybook/react-webpack5": "^9.1.13",
     "@types/bun": "latest",
+    "@types/mdast": "^4.0.4",
     "@types/node": "^22.15.26",
     "@types/react": "^19.1.12",
     "@types/react-dom": "^19.1.8",
@@ -86,12 +87,16 @@
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-storybook": "^9.1.13",
+    "mdast": "^3.0.0",
     "prettier": "^3.6.2",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
+    "remark": "^15.0.1",
+    "remark-mdx": "^3.1.1",
     "storybook": "^9.1.13",
     "typescript": "^5.0.4",
-    "typescript-eslint": "^8.38.0"
+    "typescript-eslint": "^8.38.0",
+    "unist-util-visit": "^5.0.0"
   },
   "files": [
     "dist",