codex-overleaf-link 2.1.5 → 2.2.0

package/extension/src/content/diagnosticsPanel.js

@@ -313,6 +313,129 @@
     }
   }
 
+  function formatProjectSnapshotUserLog(project, options = {}) {
+    const tx = options.tx || ((english) => english);
+    const files = project?.files || [];
+    if (!files.length) {
+      return tx(
+        'No Overleaf project files were read yet. Make sure the project has loaded, or open a .tex file in Overleaf and retry.',
+        '还没有读到 Overleaf 项目文件。请确认项目已加载完成，或在 Overleaf 点开一个 .tex 文件后重试。'
+      );
+    }
+    const textCount = files.filter(isTextSnapshotFile).length;
+    const binaryCount = files.length - textCount;
+    const resourceText = binaryCount ? tx(`, ${binaryCount} asset file(s)`, `，${binaryCount} 个资源文件`) : '';
+    const activePath = project.activePath ? tx(`, current file: ${project.activePath}`, `，当前文件：${project.activePath}`) : '';
+    const focusFiles = options.getFocusFiles?.() || [];
+    const focusText = focusFiles.length ? tx(`, focus: ${focusFiles.join(', ')}`, `，优先处理：${focusFiles.join(', ')}`) : '';
+    return tx(
+      `Read Overleaf project: ${textCount} text file(s)${resourceText}${activePath}${focusText}.`,
+      `已读取 Overleaf 项目：${textCount} 个文本文件${resourceText}${activePath}${focusText}。`
+    );
+  }
+
+  function formatProjectSnapshotFileSize(file) {
+    if (isTextSnapshotFile(file)) return `${String(file.content || '').length} chars`;
+    if (Number.isFinite(Number(file?.size))) return `${Number(file.size)} bytes`;
+    return file?.contentBase64 ? `${String(file.contentBase64).length} base64` : 'binary';
+  }
+
+  function formatProjectSnapshotWarning(warning, tx = (english => english)) {
+    if (/No source files were captured/i.test(warning)) {
+      return tx('No project source files were read. Make sure Overleaf has loaded, or open a .tex file and retry.', '没有读取到项目源文件。请确认 Overleaf 页面加载完成，或点开一个 .tex 文件后重试。');
+    }
+    if (/Full project snapshot was not captured/i.test(warning)) {
+      return tx('The full Overleaf project was not read. To avoid refreshing the local workspace from an incomplete snapshot, reload Overleaf or retry later.', '没有读到完整的 Overleaf 项目。为了避免本地 workspace 用残缺快照覆盖项目，请刷新 Overleaf 或稍后重试。');
+    }
+    if (/empty or still loading/i.test(warning)) {
+      return tx('Some file content is still loading. Wait for Overleaf to finish loading, then retry.', '读取到的文件内容还在加载中。请等 Overleaf 加载完成后重试。');
+    }
+    if (/suspiciously short|shorter than 80 characters/i.test(warning)) {
+      return tx('Some file content is very short and may not have fully loaded. Results may be incomplete.', '部分文件内容很短，可能还没完全加载。结果可能不完整。');
+    }
+    if (/identical captured content/i.test(warning)) {
+      return tx('Several files appear to have identical captured content, so Overleaf file switching may have failed. Reload and retry.', '多个文件内容看起来相同，Overleaf 文件切换可能没有成功。请刷新页面后重试。');
+    }
+    if (/were skipped/i.test(warning)) {
+      return tx('Some project files were skipped, usually images, PDFs, or unreadable files.', '有些项目文件被跳过，通常是图片、PDF 或无法读取的文件。');
+    }
+    return warning;
+  }
+
+  function appendEditorDiagnostics(editorDiagnostics, projectDiagnostics, appendLog = () => {}) {
+    if (editorDiagnostics) {
+      const active = editorDiagnostics.active;
+      appendLog(`Editor probe: active ${active?.tag || 'none'} ${active?.ariaLabel || active?.className || ''} len=${active?.valueLength || 0}; textareas=${editorDiagnostics.textareaCount || 0}; editables=${editorDiagnostics.editableCount || 0}; iframes=${editorDiagnostics.iframeCount || 0}.`);
+      if (editorDiagnostics.documentStats) {
+        const stats = editorDiagnostics.documentStats;
+        appendLog(`DOM stats: elements=${stats.elementCount || 0}; textareas=${stats.textareaCount || 0}; cm=${stats.cmCount || 0}; role textbox=${stats.roleTextboxCount || 0}.`);
+      }
+      if (editorDiagnostics.unstableStore) {
+        const store = editorDiagnostics.unstableStore;
+        const readable = (store.readable || []).map(item => `${item.path}:${item.present ? item.type : 'missing'}`).join(', ');
+        appendLog(`Overleaf store: ${store.present ? 'present' : 'missing'}${readable ? `; ${readable}` : ''}.`);
+      }
+      if (editorDiagnostics.codeMirrorView) {
+        const view = editorDiagnostics.codeMirrorView;
+        appendLog(`CodeMirror view: docLength=${view.docLength || 0}; dispatch=${Boolean(view.hasDispatch)}; source=${view.source || 'unknown'}.`);
+      }
+      if (editorDiagnostics.globals) {
+        const globals = editorDiagnostics.globals;
+        appendLog(`Overleaf globals: overleaf=${globals.overleaf || 'missing'}; Overleaf=${globals.Overleaf || 'missing'}; _ide=${globals._ide || 'missing'}.`);
+      }
+      for (const item of [...(editorDiagnostics.textareas || []), ...(editorDiagnostics.editables || [])].slice(0, 3)) {
+        appendLog(`Editor candidate: ${item.tag || 'node'} ${item.ariaLabel || item.className || item.id || ''} len=${item.valueLength || 0}.`);
+      }
+    }
+    if (projectDiagnostics) {
+      const records = projectDiagnostics.docRecords || [];
+      appendLog(`Project probe: doc records=${projectDiagnostics.docRecordCount || 0}; roots=${(projectDiagnostics.internalRootKeys || []).slice(0, 6).join(', ') || 'none'}.`);
+      for (const record of records.slice(0, 4)) appendLog(`Doc record: ${record.path} id=${record.id} source=${record.source || 'internal'}.`);
+    }
+  }
+
+  function appendProjectWarnings(project, options = {}) {
+    const warnings = options.getWarnings?.(project) || { blocking: [], nonBlocking: [] };
+    for (const warning of warnings.blocking) options.appendLog?.(`Snapshot blocked: ${warning}`);
+    for (const warning of warnings.nonBlocking) options.appendLog?.(`Snapshot warning: ${warning}`);
+  }
+
+  function isTextSnapshotFile(file) {
+    return Boolean(file && file.kind !== 'binary' && typeof file.content === 'string');
+  }
+
+  function uniqueContentSignatures(files) {
+    return Array.from(new Set(files.map(file => {
+      const content = String(file.content || '');
+      return `${content.length}:${content.slice(0, 120)}:${content.slice(-120)}`;
+    })));
+  }
+
+  function appendReviewingDiagnostics(diagnostics, options = {}) {
+    const appendLog = options.appendLog || (() => {});
+    const tx = options.tx || ((english) => english);
+    if (!diagnostics) {
+      appendLog(tx('Probe diagnostics unavailable.', '诊断探针不可用。'));
+      return;
+    }
+    appendLog(`Probe saw ${diagnostics.controlCount || 0} controls; body Reviewing=${Boolean(diagnostics.bodyTextHasReviewing)}, text Reviewing=${Boolean(diagnostics.textContentHasReviewing)}.`);
+    const controls = diagnostics.reviewLikeControls || [];
+    if (!controls.length) {
+      appendLog('Probe did not see review/track/suggest controls in the page DOM.');
+      return;
+    }
+    for (const control of controls.slice(0, 4)) {
+      const label = [
+        control.text,
+        control.ariaLabel && `aria:${control.ariaLabel}`,
+        control.title && `title:${control.title}`,
+        control.dataTestId && `test:${control.dataTestId}`,
+        control.id && `id:${control.id}`
+      ].filter(Boolean).join(' | ');
+      appendLog(`Review-like ${control.tag || 'node'}: ${label || control.htmlSnippet || '(no label)'}`);
+    }
+  }
+
   function t(instance, key, params) {
     if (typeof instance?.i18n === 'function') {
       return instance.i18n(key, params);
@@ -331,12 +454,20 @@
   }
 
   window.CodexOverleafDiagnosticsPanel = {
+    appendEditorDiagnostics,
+    appendProjectWarnings,
+    appendReviewingDiagnostics,
     create,
+    formatProjectSnapshotFileSize,
+    formatProjectSnapshotUserLog,
+    formatProjectSnapshotWarning,
+    isTextSnapshotFile,
     updateStatus,
     toggleMenu,
     closeMenu,
     closeResult,
     showLoading,
-    showResult
+    showResult,
+    uniqueContentSignatures
   };
 })();

package/extension/src/content/markdownDomRenderer.js

@@ -0,0 +1,451 @@
+(function initCodexOverleafMarkdownDomRenderer(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) {
+    module.exports = api;
+  } else {
+    root.CodexOverleafMarkdownDomRenderer = api;
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : window, function markdownDomRendererFactory() {
+  'use strict';
+
+  const DEFAULT_LIMITS = Object.freeze({
+    maxChars: 1_000_000,
+    maxTokens: 25_000,
+    maxNesting: 32
+  });
+  const BLOCK_TAGS = new Set([
+    'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'blockquote', 'ul', 'ol', 'li',
+    'table', 'thead', 'tbody', 'tr', 'th', 'td'
+  ]);
+  const INLINE_TAGS = new Map([
+    ['em_open', 'em'],
+    ['strong_open', 'strong'],
+    ['s_open', 's']
+  ]);
+  const probedFontDocuments = new WeakSet();
+  let cachedMarkdownIt = null;
+  let cachedMathText = null;
+  let cachedMaxNesting = null;
+  let cachedParser = null;
+
+  function renderMarkdown(target, value, options = {}) {
+    if (!target || typeof target.replaceChildren !== 'function') {
+      throw rendererError('markdown_target_invalid', 'Markdown target is unavailable.');
+    }
+    const document = options.document || target.ownerDocument;
+    if (!document || typeof document.createDocumentFragment !== 'function') {
+      throw rendererError('markdown_document_invalid', 'Markdown document is unavailable.');
+    }
+    const source = stripEmptyHtmlComments(String(value || ''));
+    const limits = { ...DEFAULT_LIMITS, ...(options.limits || {}) };
+    if (source.length > limits.maxChars) {
+      throw rendererError('markdown_source_too_large', `Markdown source exceeds ${limits.maxChars} UTF-16 code units.`);
+    }
+
+    const parser = options.parser || getParser({
+      markdownIt: options.markdownIt,
+      mathText: options.mathText,
+      maxNesting: limits.maxNesting
+    });
+    const tokens = parser.parse(source, {});
+    const tokenCount = countTokens(tokens);
+    if (tokenCount > limits.maxTokens) {
+      throw rendererError('markdown_token_limit', `Markdown token count exceeds ${limits.maxTokens}.`);
+    }
+
+    const fragment = document.createDocumentFragment();
+    const context = {
+      document,
+      renderTextNodes: options.renderTextNodes || (text => [document.createTextNode(text)]),
+      renderLinkNodes: options.renderLinkNodes || (label => [document.createTextNode(label)]),
+      renderCodeNodes: options.renderCodeNodes,
+      sanitizeText: options.sanitizeText || (text => String(text || '')),
+      createMathNode: options.createMathNode,
+      recordDiagnostic: options.recordDiagnostic,
+      mathRendered: false
+    };
+    renderBlockTokens(tokens, fragment, context);
+    target.replaceChildren(fragment);
+    if (context.mathRendered) {
+      probeMathFonts(document, context.recordDiagnostic);
+    }
+    return { tokenCount };
+  }
+
+  function getParser({ markdownIt, mathText, maxNesting }) {
+    if (typeof markdownIt !== 'function') {
+      throw rendererError('markdown_parser_missing', 'The vendored Markdown parser is unavailable.');
+    }
+    if (!mathText || typeof mathText.matchMathAt !== 'function') {
+      throw rendererError('markdown_math_rule_missing', 'The shared math delimiter matcher is unavailable.');
+    }
+    if (
+      cachedParser &&
+      cachedMarkdownIt === markdownIt &&
+      cachedMathText === mathText &&
+      cachedMaxNesting === maxNesting
+    ) {
+      return cachedParser;
+    }
+    const parser = markdownIt({
+      html: false,
+      linkify: false,
+      typographer: false,
+      breaks: false,
+      maxNesting
+    });
+    installMathRules(parser, mathText);
+    cachedMarkdownIt = markdownIt;
+    cachedMathText = mathText;
+    cachedMaxNesting = maxNesting;
+    cachedParser = parser;
+    return parser;
+  }
+
+  function installMathRules(parser, mathText) {
+    parser.inline.ruler.before('escape', 'codex_math_inline', (state, silent) => {
+      const match = mathText.matchMathAt(state.src, state.pos);
+      if (!match) {
+        return false;
+      }
+      if (!silent) {
+        const token = state.push('math_inline', 'span', 0);
+        token.content = match.value;
+        token.markup = match.raw.slice(0, 2);
+        token.meta = { display: match.display, raw: match.raw };
+      }
+      state.pos = match.end;
+      return true;
+    });
+
+    parser.block.ruler.before('lheading', 'codex_math_block', (state, startLine, endLine, silent) => {
+      const start = state.bMarks[startLine] + state.tShift[startLine];
+      const match = mathText.matchMathAt(state.src, start);
+      if (!match || !match.display) {
+        return false;
+      }
+      let lastLine = startLine;
+      while (lastLine < endLine && state.eMarks[lastLine] < match.end) {
+        lastLine += 1;
+      }
+      if (lastLine >= endLine || state.src.slice(match.end, state.eMarks[lastLine]).trim()) {
+        return false;
+      }
+      if (silent) {
+        return true;
+      }
+      const token = state.push('math_block', 'div', 0);
+      token.block = true;
+      token.content = match.value;
+      token.map = [startLine, lastLine + 1];
+      token.markup = match.raw.slice(0, 2);
+      token.meta = { display: true, raw: match.raw };
+      state.line = lastLine + 1;
+      return true;
+    }, { alt: ['paragraph', 'reference', 'blockquote', 'list'] });
+  }
+
+  function renderBlockTokens(tokens, rootNode, context) {
+    const stack = [{ node: rootNode, closeType: '' }];
+    for (let index = 0; index < tokens.length; index += 1) {
+      const token = tokens[index];
+      const parent = stack[stack.length - 1].node;
+
+      if (
+        token.type === 'paragraph_open' &&
+        tokens[index + 1]?.type === 'inline' &&
+        tokens[index + 2]?.type === 'paragraph_close'
+      ) {
+        const children = tokens[index + 1].children || [];
+        if (token.hidden) {
+          renderInlineTokens(children, parent, context);
+        } else {
+          renderParagraphFlow(children, parent, context);
+        }
+        index += 2;
+        continue;
+      }
+
+      if (token.type === 'inline') {
+        renderInlineTokens(token.children || [], parent, context);
+        continue;
+      }
+      if (token.type === 'fence' || token.type === 'code_block') {
+        appendCodeBlock(parent, token, context);
+        continue;
+      }
+      if (token.type === 'math_block') {
+        parent.append(createMathNode(token, context, true));
+        continue;
+      }
+      if (token.type === 'hr') {
+        parent.append(context.document.createElement('hr'));
+        continue;
+      }
+      if (token.nesting === 1) {
+        const node = createBlockContainer(token, context);
+        parent.append(node);
+        stack.push({
+          node,
+          closeType: token.type.replace(/_open$/, '_close')
+        });
+        continue;
+      }
+      if (token.nesting === -1) {
+        const frame = stack.pop();
+        if (!frame || frame.closeType !== token.type || stack.length === 0) {
+          throw rendererError('markdown_structure_invalid', `Unexpected closing token: ${token.type}.`);
+        }
+        continue;
+      }
+      throw rendererError('markdown_token_unsupported', `Unsupported Markdown token: ${token.type}.`);
+    }
+    if (stack.length !== 1) {
+      throw rendererError('markdown_structure_invalid', 'Markdown token nesting did not close cleanly.');
+    }
+  }
+
+  function createBlockContainer(token, context) {
+    const tag = String(token.tag || '').toLowerCase();
+    if (!BLOCK_TAGS.has(tag)) {
+      throw rendererError('markdown_block_unsupported', `Unsupported Markdown container: ${tag || token.type}.`);
+    }
+    const node = context.document.createElement(tag);
+    if (tag === 'table') {
+      node.className = 'run-markdown-table';
+    }
+    if (tag === 'blockquote') {
+      node.className = 'run-markdown-quote';
+    }
+    if (tag === 'ol') {
+      const start = Number(token.attrGet?.('start'));
+      if (Number.isSafeInteger(start) && start > 1) {
+        node.setAttribute('start', String(start));
+      }
+    }
+    if (tag === 'th' || tag === 'td') {
+      const alignment = String(token.attrGet?.('style') || '').match(/text-align:\s*(left|center|right)/i)?.[1];
+      if (alignment) {
+        node.classList.add(`is-align-${alignment.toLowerCase()}`);
+      }
+    }
+    return node;
+  }
+
+  function appendCodeBlock(parent, token, context) {
+    const pre = context.document.createElement('pre');
+    pre.className = 'run-code-block';
+    const code = context.document.createElement('code');
+    code.textContent = context.sanitizeText(token.content || '');
+    const language = String(token.info || '').trim().split(/\s+/)[0].replace(/[^a-z0-9_-]/gi, '');
+    if (language) {
+      code.className = `language-${language}`;
+    }
+    pre.append(code);
+    parent.append(pre);
+  }
+
+  function renderParagraphFlow(tokens, parent, context) {
+    let segment = [];
+    const flush = () => {
+      if (!segment.length) {
+        return;
+      }
+      const paragraph = context.document.createElement('p');
+      const meaningful = segment.filter(token => token.type !== 'softbreak' && (
+        token.type !== 'text' || String(token.content || '').trim()
+      ));
+      renderInlineTokens(segment, paragraph, context, {
+        standaloneCode: meaningful.length === 1 && meaningful[0].type === 'code_inline'
+      });
+      if (paragraphHasContent(paragraph)) {
+        parent.append(paragraph);
+      }
+      segment = [];
+    };
+    let nesting = 0;
+    for (const token of tokens) {
+      if (token.nesting === 1) nesting += 1;
+      if (token.type === 'math_inline' && token.meta?.display && nesting === 0) {
+        flush();
+        parent.append(createMathNode(token, context, true));
+        continue;
+      }
+      segment.push(token);
+      if (token.nesting === -1) nesting = Math.max(0, nesting - 1);
+    }
+    flush();
+  }
+
+  function paragraphHasContent(node) {
+    return Boolean(node.childNodes?.length || String(node.textContent || '').trim());
+  }
+
+  function renderInlineTokens(tokens, rootNode, context, renderOptions = {}) {
+    const stack = [{ node: rootNode, closeType: '' }];
+    for (let index = 0; index < tokens.length; index += 1) {
+      const token = tokens[index];
+      const parent = stack[stack.length - 1].node;
+      if (token.type === 'text' || token.type === 'html_inline') {
+        appendNodes(parent, context.renderTextNodes(context.sanitizeText(token.content || '')));
+        continue;
+      }
+      if (token.type === 'softbreak') {
+        parent.append(context.document.createTextNode(' '));
+        continue;
+      }
+      if (token.type === 'hardbreak') {
+        parent.append(context.document.createElement('br'));
+        continue;
+      }
+      if (token.type === 'code_inline') {
+        if (renderOptions.standaloneCode && typeof context.renderCodeNodes === 'function') {
+          appendNodes(parent, context.renderCodeNodes(context.sanitizeText(token.content || '')));
+          continue;
+        }
+        const code = context.document.createElement('code');
+        code.className = 'run-inline-code';
+        code.textContent = context.sanitizeText(token.content || '');
+        parent.append(code);
+        continue;
+      }
+      if (token.type === 'math_inline') {
+        parent.append(createMathNode(token, context, Boolean(token.meta?.display)));
+        continue;
+      }
+      if (token.type === 'image') {
+        appendNodes(parent, context.renderTextNodes(context.sanitizeText(token.content || token.attrGet?.('alt') || '')));
+        continue;
+      }
+      if (token.type === 'link_open') {
+        const closeIndex = findMatchingInlineClose(tokens, index, 'link_open', 'link_close');
+        const label = extractInlineText(tokens.slice(index + 1, closeIndex));
+        const href = String(token.attrGet?.('href') || '');
+        appendNodes(parent, context.renderLinkNodes(context.sanitizeText(label), href));
+        index = closeIndex;
+        continue;
+      }
+      if (INLINE_TAGS.has(token.type)) {
+        const node = context.document.createElement(INLINE_TAGS.get(token.type));
+        parent.append(node);
+        stack.push({ node, closeType: token.type.replace(/_open$/, '_close') });
+        continue;
+      }
+      if (token.nesting === -1) {
+        const frame = stack.pop();
+        if (!frame || frame.closeType !== token.type || stack.length === 0) {
+          throw rendererError('markdown_inline_structure_invalid', `Unexpected inline closing token: ${token.type}.`);
+        }
+        continue;
+      }
+      throw rendererError('markdown_inline_unsupported', `Unsupported inline Markdown token: ${token.type}.`);
+    }
+    if (stack.length !== 1) {
+      throw rendererError('markdown_inline_structure_invalid', 'Inline Markdown token nesting did not close cleanly.');
+    }
+  }
+
+  function findMatchingInlineClose(tokens, start, openType, closeType) {
+    let depth = 0;
+    for (let index = start; index < tokens.length; index += 1) {
+      if (tokens[index].type === openType) depth += 1;
+      if (tokens[index].type === closeType) depth -= 1;
+      if (depth === 0) return index;
+    }
+    throw rendererError('markdown_link_unclosed', 'Markdown link did not close cleanly.');
+  }
+
+  function extractInlineText(tokens) {
+    return tokens.map(token => {
+      if (token.type === 'image') return token.content || token.attrGet?.('alt') || '';
+      if (token.children) return extractInlineText(token.children);
+      return token.content || '';
+    }).join('');
+  }
+
+  function createMathNode(token, context, forceDisplay) {
+    if (typeof context.createMathNode !== 'function') {
+      throw rendererError('markdown_math_renderer_missing', 'The KaTeX node renderer is unavailable.');
+    }
+    const display = Boolean(forceDisplay || token.meta?.display);
+    const raw = token.meta?.raw || (display ? `$$${token.content}$$` : `$${token.content}$`);
+    const node = context.createMathNode({
+      type: 'math',
+      raw,
+      value: token.content,
+      display
+    });
+    if (!node) {
+      throw rendererError('markdown_math_node_invalid', 'The KaTeX node renderer returned no node.');
+    }
+    context.mathRendered = true;
+    return node;
+  }
+
+  function appendNodes(parent, value) {
+    const nodes = Array.isArray(value) ? value : (value ? [value] : []);
+    for (const node of nodes) {
+      if (node) parent.append(node);
+    }
+  }
+
+  function countTokens(tokens) {
+    let total = 0;
+    const visit = list => {
+      for (const token of list || []) {
+        total += 1;
+        if (token.children?.length) visit(token.children);
+      }
+    };
+    visit(tokens);
+    return total;
+  }
+
+  function stripEmptyHtmlComments(value) {
+    return String(value || '').replace(/<!--\s*-->/g, '');
+  }
+
+  function probeMathFonts(document, recordDiagnostic) {
+    const fonts = document.fonts;
+    if (!fonts || typeof fonts.load !== 'function' || probedFontDocuments.has(document)) {
+      return;
+    }
+    probedFontDocuments.add(document);
+    const families = ['KaTeX_Main', 'KaTeX_Math', 'KaTeX_AMS', 'KaTeX_Size1'];
+    Promise.allSettled(families.map(family => fonts.load(`16px "${family}"`)))
+      .then(async results => {
+        await Promise.resolve(fonts.ready);
+        const missing = results.flatMap((result, index) => (
+          result.status === 'rejected' || !result.value?.length ? [families[index]] : []
+        ));
+        if (missing.length && typeof recordDiagnostic === 'function') {
+          recordDiagnostic({
+            code: 'katex_font_load_incomplete',
+            detail: `KaTeX font families did not load: ${missing.join(', ')}`
+          });
+        }
+      })
+      .catch(() => {
+        if (typeof recordDiagnostic === 'function') {
+          recordDiagnostic({
+            code: 'katex_font_probe_failed',
+            detail: 'KaTeX font readiness could not be verified.'
+          });
+        }
+      });
+  }
+
+  function rendererError(code, message) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+  }
+
+  return {
+    DEFAULT_LIMITS,
+    countTokens,
+    renderMarkdown,
+    stripEmptyHtmlComments
+  };
+});