@mgks/docmd 0.2.7 → 0.2.8

package/src/core/markdown/containers.js

@@ -0,0 +1,94 @@
+// Source file from the docmd project — https://github.com/mgks/docmd
+
+const containers = {
+  card: {
+    name: 'card',
+    render: (tokens, idx) => {
+      if (tokens[idx].nesting === 1) {
+        const title = tokens[idx].info ? tokens[idx].info.trim() : '';
+        return `<div class="docmd-container card">${title ? `<div class="card-title">${title}</div>` : ''}<div class="card-content">`;
+      }
+      return '</div></div>';
+    }
+  },
+  callout: {
+    name: 'callout',
+    render: (tokens, idx) => {
+      if (tokens[idx].nesting === 1) {
+        const [type, ...titleParts] = tokens[idx].info.split(' ');
+        const title = titleParts.join(' ');
+        return `<div class="docmd-container callout callout-${type}">${title ? `<div class="callout-title">${title}</div>` : ''}<div class="callout-content">`;
+      }
+      return '</div></div>';
+    }
+  },
+  button: {
+    name: 'button',
+    selfClosing: true,
+    render: (tokens, idx) => {
+      if (tokens[idx].nesting === 1) {
+        const parts = tokens[idx].info.split(' ');
+        const text = parts[0];
+        const url = parts[1];
+        const color = parts[2];
+        const colorStyle = color && color.startsWith('color:') ? ` style="background-color: ${color.split(':')[1]}"` : '';
+        
+        let finalUrl = url;
+        let targetAttr = '';
+        if (url && url.startsWith('external:')) {
+          finalUrl = url.substring(9);
+          targetAttr = ' target="_blank" rel="noopener noreferrer"';
+        }
+        
+        return `<a href="${finalUrl}" class="docmd-button"${colorStyle}${targetAttr}>${text.replace(/_/g, ' ')}</a>`;
+      }
+      return '';
+    }
+  },
+  steps: {
+    name: 'steps',
+    render: (tokens, idx) => {
+      if (tokens[idx].nesting === 1) {
+        return '<div class="docmd-container steps steps-reset steps-numbering">';
+      }
+      return '</div>';
+    }
+  },
+  collapsible: {
+    name: 'collapsible',
+    render: (tokens, idx) => {
+      if (tokens[idx].nesting === 1) {
+        const info = tokens[idx].info.trim();
+        let isOpen = false;
+        let displayTitle = info;
+
+        if (info.startsWith('open ')) {
+          isOpen = true;
+          displayTitle = info.substring(5);
+        }
+        if (!displayTitle) displayTitle = 'Click to expand';
+
+        return `<details class="docmd-container collapsible" ${isOpen ? 'open' : ''}>
+          <summary class="collapsible-summary">
+            <span class="collapsible-title">${displayTitle}</span>
+            <span class="collapsible-arrow">
+              <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-chevron-down"><path d="m6 9 6 6 6-6"/></svg>
+            </span>
+          </summary>
+          <div class="collapsible-content">`;
+      }
+      return '</div></details>\n';
+    }
+  },
+  changelog: {
+    name: 'changelog',
+    render: (tokens, idx) => {
+      if (tokens[idx].nesting === 1) {
+        return '<div class="docmd-container changelog-timeline">';
+      }
+      return '</div>';
+    }
+  }
+};
+
+module.exports = { containers };

package/src/core/markdown/renderers.js

@@ -0,0 +1,90 @@
+// Source file from the docmd project — https://github.com/mgks/docmd
+
+const customOrderedListOpenRenderer = function(tokens, idx, options, env, self) {
+  const token = tokens[idx];
+  let isInSteps = false;
+  for (let i = idx - 1; i >= 0; i--) {
+    if (tokens[i].type === 'container_steps_open') {
+      isInSteps = true;
+      break;
+    }
+    if (tokens[i].type === 'container_steps_close') {
+      break;
+    }
+  }
+  if (isInSteps) {
+    const start = token.attrGet('start');
+    return start ? `<ol class="steps-list" start="${start}">` : '<ol class="steps-list">';
+  }
+  const start = token.attrGet('start');
+  return start ? `<ol start="${start}">` : '<ol>';
+};
+
+const customListItemOpenRenderer = function(tokens, idx, options, env, self) {
+  const token = tokens[idx];
+  let isInStepsList = false;
+  for (let i = idx - 1; i >= 0; i--) {
+    if (tokens[i].type === 'ordered_list_open' && tokens[i].markup && tokens[i].level < token.level) {
+      let j = i - 1;
+      while (j >= 0) {
+        if (tokens[j].type === 'container_steps_open') {
+          isInStepsList = true;
+          break;
+        }
+        if (tokens[j].type === 'container_steps_close') {
+          break;
+        }
+        j--;
+      }
+      break;
+    }
+  }
+  if (isInStepsList) {
+    return '<li class="step-item">';
+  }
+  return '<li>';
+};
+
+const customImageRenderer = function(tokens, idx, options, env, self) {
+  const defaultImageRenderer = function(tokens, idx, options, env, self) { return self.renderToken(tokens, idx, options); };
+  const renderedImage = defaultImageRenderer(tokens, idx, options, env, self);
+  const nextToken = tokens[idx + 1];
+  if (nextToken && nextToken.type === 'attrs_block') {
+    const attrs = nextToken.attrs || [];
+    const attrsStr = attrs.map(([name, value]) => `${name}="${value}"`).join(' ');
+    return renderedImage.replace('<img ', `<img ${attrsStr} `);
+  }
+  return renderedImage;
+};
+
+// Table Wrapper for horizontal scrolling
+const tableOpenRenderer = (tokens, idx, options, env, self) => '<div class="table-wrapper">' + self.renderToken(tokens, idx, options);
+const tableCloseRenderer = (tokens, idx, options, env, self) => self.renderToken(tokens, idx, options) + '</div>';
+
+// Tabs Renderers
+const tabsOpenRenderer = (tokens, idx) => `<div class="${tokens[idx].attrs.map(attr => attr[1]).join(' ')}">`;
+const tabsNavOpenRenderer = () => '<div class="docmd-tabs-nav">';
+const tabsNavCloseRenderer = () => '</div>';
+const tabsNavItemRenderer = (tokens, idx) => `<div class="${tokens[idx].attrs[0][1]}">${tokens[idx].content}</div>`;
+const tabsContentOpenRenderer = () => '<div class="docmd-tabs-content">';
+const tabsContentCloseRenderer = () => '</div>';
+const tabPaneOpenRenderer = (tokens, idx) => `<div class="${tokens[idx].attrs[0][1]}">`;
+const tabPaneCloseRenderer = () => '</div>';
+const tabsCloseRenderer = () => '</div>';
+
+module.exports = {
+  customOrderedListOpenRenderer,
+  customListItemOpenRenderer,
+  customImageRenderer,
+  tableOpenRenderer,
+  tableCloseRenderer,
+  tabsOpenRenderer,
+  tabsNavOpenRenderer,
+  tabsNavCloseRenderer,
+  tabsNavItemRenderer,
+  tabsContentOpenRenderer,
+  tabsContentCloseRenderer,
+  tabPaneOpenRenderer,
+  tabPaneCloseRenderer,
+  tabsCloseRenderer
+};

package/src/core/markdown/rules.js

@@ -0,0 +1,355 @@
+// Source file from the docmd project — https://github.com/mgks/docmd
+
+const MarkdownIt = require('markdown-it'); // Required for inner rendering fallback logic
+const { containers } = require('./containers');
+
+// --- Helper: Create isolated parser for tabs (prevents recursion stack issues) ---
+// Note: We pass a callback to get the main config logic from setup.js later if needed,
+// but for now we reconstruct a basic one for tab/changelog internals to ensure plugins run.
+// Ideally, we prefer reusing state.md.render() where possible.
+
+// --- 1. Advanced Container Rule (Nesting Logic) ---
+function advancedContainerRule(state, startLine, endLine, silent) {
+  const start = state.bMarks[startLine] + state.tShift[startLine];
+  const max = state.eMarks[startLine];
+  const lineContent = state.src.slice(start, max).trim();
+  
+  const containerMatch = lineContent.match(/^:::\s*(\w+)(?:\s+(.+))?$/);
+  if (!containerMatch) return false;
+  
+  const [, containerName, params] = containerMatch;
+  const container = containers[containerName];
+  if (!container) return false;
+  if (silent) return true;
+  
+  if (container.selfClosing) {
+    const openToken = state.push(`container_${containerName}_open`, 'div', 1);
+    openToken.info = params || '';
+    const closeToken = state.push(`container_${containerName}_close`, 'div', -1);
+    state.line = startLine + 1;
+    return true;
+  }
+  
+  let nextLine = startLine;
+  let found = false;
+  let depth = 1;
+  
+  while (nextLine < endLine) {
+    nextLine++;
+    const nextStart = state.bMarks[nextLine] + state.tShift[nextLine];
+    const nextMax = state.eMarks[nextLine];
+    const nextContent = state.src.slice(nextStart, nextMax).trim();
+    
+    if (nextContent.startsWith(':::')) {
+      const containerMatch = nextContent.match(/^:::\s*(\w+)/);
+      if (containerMatch && containerMatch[1] !== containerName) {
+        const innerContainer = containers[containerMatch[1]];
+        if (innerContainer && innerContainer.render && !innerContainer.selfClosing) {
+          depth++;
+        }
+        continue;
+      }
+    }
+    
+    if (nextContent === ':::') {
+      depth--;
+      if (depth === 0) {
+        found = true;
+        break;
+      }
+    }
+  }
+  
+  if (!found) return false;
+  
+  const openToken = state.push(`container_${containerName}_open`, 'div', 1);
+  openToken.info = params || '';
+  
+  const oldParentType = state.parentType;
+  const oldLineMax = state.lineMax;
+  state.parentType = 'container';
+  state.lineMax = nextLine;
+  
+  state.md.block.tokenize(state, startLine + 1, nextLine);
+  
+  const closeToken = state.push(`container_${containerName}_close`, 'div', -1);
+  
+  state.parentType = oldParentType;
+  state.lineMax = oldLineMax;
+  state.line = nextLine + 1;
+  
+  return true;
+}
+
+// --- 2. Changelog Timeline Rule (FIXED FOR NESTING) ---
+function changelogTimelineRule(state, startLine, endLine, silent) {
+  const start = state.bMarks[startLine] + state.tShift[startLine];
+  const max = state.eMarks[startLine];
+  const lineContent = state.src.slice(start, max).trim();
+
+  if (lineContent !== '::: changelog') return false;
+  if (silent) return true;
+
+  let nextLine = startLine;
+  let found = false;
+  let depth = 1;
+  
+  while (nextLine < endLine) {
+    nextLine++;
+    const nextStart = state.bMarks[nextLine] + state.tShift[nextLine];
+    const nextMax = state.eMarks[nextLine];
+    const nextContent = state.src.slice(nextStart, nextMax).trim();
+    
+    if (nextContent.startsWith(':::')) {
+      const match = nextContent.match(/^:::\s*(\w+)/);
+      if (match) {
+        const containerName = match[1];
+        // Don't count self-closing like buttons for depth
+        const containerDef = containers[containerName];
+        if (!containerDef || !containerDef.selfClosing) {
+           depth++;
+        }
+      }
+    }
+    
+    if (nextContent === ':::') {
+      depth--;
+      if (depth === 0) { found = true; break; }
+    }
+  }
+  
+  if (!found) return false;
+
+  let content = '';
+  for (let i = startLine + 1; i < nextLine; i++) {
+    const lineStart = state.bMarks[i] + state.tShift[i];
+    const lineEnd = state.eMarks[i];
+    content += state.src.slice(lineStart, lineEnd) + '\n';
+  }
+
+  const lines = content.split('\n');
+  const entries = [];
+  let currentEntry = null;
+  let currentContent = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const markerMatch = line.match(/^==\s+(.+)$/);
+
+    if (markerMatch) {
+      if (currentEntry) {
+        currentEntry.content = currentContent.join('\n');
+        entries.push(currentEntry);
+      }
+      currentEntry = { meta: markerMatch[1], content: '' };
+      currentContent = [];
+    } else if (currentEntry) {
+      currentContent.push(lines[i]); 
+    }
+  }
+  if (currentEntry) {
+    currentEntry.content = currentContent.join('\n');
+    entries.push(currentEntry);
+  }
+
+  state.push('container_changelog_open', 'div', 1);
+
+  entries.forEach(entry => {
+    const entryOpen = state.push('html_block', '', 0);
+    entryOpen.content = `<div class="changelog-entry">
+      <div class="changelog-meta"><span class="changelog-date">${entry.meta}</span></div>
+      <div class="changelog-body">`;
+
+    // --- FIX: Use parent parser to render inner content ---
+    // This ensures callouts/cards inside changelogs are parsed
+    entryOpen.content += state.md.render(entry.content, state.env);
+    
+    const entryClose = state.push('html_block', '', 0);
+    entryClose.content = `</div></div>`;
+  });
+
+  state.push('container_changelog_close', 'div', -1);
+  state.line = nextLine + 1;
+  return true;
+}
+
+// --- 3. Steps Container Rule ---
+function stepsContainerRule(state, startLine, endLine, silent) {
+    const start = state.bMarks[startLine] + state.tShift[startLine];
+    const max = state.eMarks[startLine];
+    const lineContent = state.src.slice(start, max).trim();
+    if (lineContent !== '::: steps') return false;
+    if (silent) return true;
+  
+    let nextLine = startLine;
+    let found = false;
+    let depth = 1;
+    
+    while (nextLine < endLine) {
+      nextLine++;
+      const nextStart = state.bMarks[nextLine] + state.tShift[nextLine];
+      const nextMax = state.eMarks[nextLine];
+      const nextContent = state.src.slice(nextStart, nextMax).trim();
+      
+      if (nextContent.startsWith('== tab')) { continue; }
+      
+      if (nextContent.startsWith(':::')) {
+        const containerMatch = nextContent.match(/^:::\s*(\w+)/);
+        if (containerMatch) {
+          const containerName = containerMatch[1];
+          const innerContainer = containers[containerName];
+          if (innerContainer && !innerContainer.selfClosing) {
+            depth++;
+          }
+          continue;
+        }
+      }
+      
+      if (nextContent === ':::') {
+        depth--;
+        if (depth === 0) { found = true; break; }
+      }
+    }
+    
+    if (!found) return false;
+  
+    const openToken = state.push('container_steps_open', 'div', 1);
+    openToken.info = '';
+    
+    const oldParentType = state.parentType;
+    const oldLineMax = state.lineMax;
+    state.parentType = 'container';
+    state.lineMax = nextLine;
+    state.md.block.tokenize(state, startLine + 1, nextLine);
+    const closeToken = state.push('container_steps_close', 'div', -1);
+    state.parentType = oldParentType;
+    state.lineMax = oldLineMax;
+    state.line = nextLine + 1;
+    return true;
+}
+
+// --- 4. Enhanced Tabs Rule ---
+function enhancedTabsRule(state, startLine, endLine, silent) {
+  const start = state.bMarks[startLine] + state.tShift[startLine];
+  const max = state.eMarks[startLine];
+  const lineContent = state.src.slice(start, max).trim();
+
+  if (lineContent !== '::: tabs') return false;
+  if (silent) return true;
+
+  let nextLine = startLine;
+  let found = false;
+  let depth = 1;
+  while (nextLine < endLine) {
+    nextLine++;
+    const nextStart = state.bMarks[nextLine] + state.tShift[nextLine];
+    const nextMax = state.eMarks[nextLine];
+    const nextContent = state.src.slice(nextStart, nextMax).trim();
+    
+    if (nextContent.startsWith(':::')) {
+      const containerMatch = nextContent.match(/^:::\s*(\w+)/);
+      if (containerMatch && containerMatch[1] !== 'tabs') {
+        if (containerMatch[1] === 'steps') continue;
+        const innerContainer = containers[containerMatch[1]];
+        if (innerContainer && !innerContainer.selfClosing) depth++;
+        continue;
+      }
+    }
+    
+    if (nextContent === ':::') {
+      depth--;
+      if (depth === 0) { found = true; break; }
+    }
+  }
+  if (!found) return false;
+
+  let content = '';
+  for (let i = startLine + 1; i < nextLine; i++) {
+    const lineStart = state.bMarks[i] + state.tShift[i];
+    const lineEnd = state.eMarks[i];
+    content += state.src.slice(lineStart, lineEnd) + '\n';
+  }
+
+  const lines = content.split('\n');
+  const tabs = [];
+  let currentTab = null;
+  let currentContent = [];
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const tabMatch = line.match(/^==\s*tab\s+(?:"([^"]+)"|(\S+))$/);
+    
+    if (tabMatch) {
+      if (currentTab) {
+        currentTab.content = currentContent.join('\n').trim();
+        tabs.push(currentTab);
+      }
+      const title = tabMatch[1] || tabMatch[2];
+      currentTab = { title: title, content: '' };
+      currentContent = [];
+    } else if (currentTab) {
+      if (lines[i].trim() && !lines[i].trim().startsWith('==')) {
+        currentContent.push(lines[i]);
+      }
+    }
+  }
+  if (currentTab) {
+    currentTab.content = currentContent.join('\n').trim();
+    tabs.push(currentTab);
+  }
+
+  const openToken = state.push('tabs_open', 'div', 1);
+  openToken.attrs = [['class', 'docmd-tabs']];
+  
+  const navToken = state.push('tabs_nav_open', 'div', 1);
+  navToken.attrs = [['class', 'docmd-tabs-nav']];
+  tabs.forEach((tab, index) => {
+    const navItemToken = state.push('tabs_nav_item', 'div', 0);
+    navItemToken.attrs = [['class', `docmd-tabs-nav-item ${index === 0 ? 'active' : ''}`]];
+    navItemToken.content = tab.title;
+  });
+  state.push('tabs_nav_close', 'div', -1);
+  
+  const contentToken = state.push('tabs_content_open', 'div', 1);
+  contentToken.attrs = [['class', 'docmd-tabs-content']];
+  tabs.forEach((tab, index) => {
+    const paneToken = state.push('tab_pane_open', 'div', 1);
+    paneToken.attrs = [['class', `docmd-tab-pane ${index === 0 ? 'active' : ''}`]];
+    
+    if (tab.content.trim()) {
+        // Use recursion here if possible, or create basic instance to prevent circular dep issues in this modular file
+        // Since we are inside rules.js, we rely on state.md being available or fallback to simple render
+        const renderedContent = state.md.render(tab.content.trim(), state.env);
+        const htmlToken = state.push('html_block', '', 0);
+        htmlToken.content = renderedContent;
+    }
+    
+    state.push('tab_pane_close', 'div', -1);
+  });
+  state.push('tabs_content_close', 'div', -1);
+  state.push('tabs_close', 'div', -1);
+  state.line = nextLine + 1;
+  return true;
+}
+
+// --- 5. Standalone Closing Rule ---
+const standaloneClosingRule = (state, startLine, endLine, silent) => {
+  const start = state.bMarks[startLine] + state.tShift[startLine];
+  const max = state.eMarks[startLine];
+  const lineContent = state.src.slice(start, max).trim();
+  
+  if (lineContent === ':::') {
+    if (silent) return true;
+    state.line = startLine + 1;
+    return true;
+  }
+  return false;
+};
+
+module.exports = {
+  advancedContainerRule,
+  changelogTimelineRule,
+  stepsContainerRule,
+  enhancedTabsRule,
+  standaloneClosingRule
+};

package/src/core/markdown/setup.js

@@ -0,0 +1,108 @@
+// Source file from the docmd project — https://github.com/mgks/docmd
+
+const MarkdownIt = require('markdown-it');
+const hljs = require('highlight.js');
+const attrs = require('markdown-it-attrs');
+const markdown_it_footnote = require('markdown-it-footnote');
+const markdown_it_task_lists = require('markdown-it-task-lists');
+const markdown_it_abbr = require('markdown-it-abbr');
+const markdown_it_deflist = require('markdown-it-deflist');
+
+const { containers } = require('./containers');
+const rules = require('./rules');
+const renderers = require('./renderers');
+
+// Custom plugin for Heading IDs
+const headingIdPlugin = (md) => {
+  const originalHeadingOpen = md.renderer.rules.heading_open || function(tokens, idx, options, env, self) {
+    return self.renderToken(tokens, idx, options);
+  };
+  md.renderer.rules.heading_open = function(tokens, idx, options, env, self) {
+    const token = tokens[idx];
+    const contentToken = tokens[idx + 1];
+    if (contentToken && contentToken.type === 'inline' && contentToken.content) {
+      const headingText = contentToken.content;
+      const id = headingText
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^\w-]+/g, '')
+        .replace(/--+/g, '-')
+        .replace(/^-+/, '')
+        .replace(/-+$/, '');
+      if (id) token.attrSet('id', id);
+    }
+    return originalHeadingOpen(tokens, idx, options, env, self);
+  };
+};
+
+function createMarkdownItInstance(config) {
+  const mdOptions = {
+    html: true,
+    linkify: true,
+    typographer: true,
+    breaks: true,
+  };
+  
+  const highlightFn = (str, lang) => {
+    if (lang === 'mermaid') {
+      return `<pre class="mermaid">${new MarkdownIt().utils.escapeHtml(str)}</pre>`;
+    }
+    if (lang && hljs.getLanguage(lang)) {
+      try {
+        return `<pre class="hljs"><code>${hljs.highlight(str, { language: lang, ignoreIllegals: true }).value}</code></pre>`;
+      } catch (e) { console.error(e); }
+    }
+    return `<pre class="hljs"><code>${new MarkdownIt().utils.escapeHtml(str)}</code></pre>`;
+  };
+
+  mdOptions.highlight = config.theme?.codeHighlight !== false ? highlightFn : (str, lang) => {
+      if (lang === 'mermaid') return `<pre class="mermaid">${new MarkdownIt().utils.escapeHtml(str)}</pre>`;
+      return `<pre><code>${new MarkdownIt().utils.escapeHtml(str)}</code></pre>`;
+  };
+
+  const md = new MarkdownIt(mdOptions);
+
+  // Plugins
+  md.use(attrs, { leftDelimiter: '{', rightDelimiter: '}' });
+  md.use(markdown_it_footnote);
+  md.use(markdown_it_task_lists);
+  md.use(markdown_it_abbr);
+  md.use(markdown_it_deflist);
+  md.use(headingIdPlugin);
+
+  // Register Containers
+  Object.keys(containers).forEach(containerName => {
+    const container = containers[containerName];
+    md.renderer.rules[`container_${containerName}_open`] = container.render;
+    md.renderer.rules[`container_${containerName}_close`] = container.render;
+  });
+
+  // Register Rules (Order Matters)
+  md.block.ruler.before('fence', 'steps_container', rules.stepsContainerRule, { alt: ['paragraph', 'reference', 'blockquote', 'list'] });
+  md.block.ruler.before('fence', 'enhanced_tabs', rules.enhancedTabsRule, { alt: ['paragraph', 'reference', 'blockquote', 'list'] });
+  md.block.ruler.before('fence', 'changelog_timeline', rules.changelogTimelineRule, { alt: ['paragraph', 'reference', 'blockquote', 'list'] });
+  md.block.ruler.before('paragraph', 'advanced_container', rules.advancedContainerRule, { alt: ['paragraph', 'reference', 'blockquote', 'list'] });
+  md.block.ruler.before('paragraph', 'standalone_closing', rules.standaloneClosingRule, { alt: ['paragraph', 'reference', 'blockquote', 'list'] });
+
+  // Register Renderers
+  md.renderer.rules.ordered_list_open = renderers.customOrderedListOpenRenderer;
+  md.renderer.rules.list_item_open = renderers.customListItemOpenRenderer;
+  md.renderer.rules.image = renderers.customImageRenderer;
+  md.renderer.rules.table_open = renderers.tableOpenRenderer;
+  md.renderer.rules.table_close = renderers.tableCloseRenderer;
+
+  // Tabs Renderers
+  md.renderer.rules.tabs_open = renderers.tabsOpenRenderer;
+  md.renderer.rules.tabs_nav_open = renderers.tabsNavOpenRenderer;
+  md.renderer.rules.tabs_nav_close = renderers.tabsNavCloseRenderer;
+  md.renderer.rules.tabs_nav_item = renderers.tabsNavItemRenderer;
+  md.renderer.rules.tabs_content_open = renderers.tabsContentOpenRenderer;
+  md.renderer.rules.tabs_content_close = renderers.tabsContentCloseRenderer;
+  md.renderer.rules.tab_pane_open = renderers.tabPaneOpenRenderer;
+  md.renderer.rules.tab_pane_close = renderers.tabPaneCloseRenderer;
+  md.renderer.rules.tabs_close = renderers.tabsCloseRenderer;
+
+  return md;
+}
+
+module.exports = { createMarkdownItInstance };