Spaces:

openbmb
/

UltraData-Math-L0-Parser

Running

App Files Files Community

ZhouChuYue commited on 20 days ago

Commit

a579dd2

1 Parent(s): aa1ad34

init

Browse files

Files changed (20) hide show

app.py +373 -0
requirements.txt +9 -0
ultradata_math_parser/__init__.py +109 -0
ultradata_math_parser/config.py +332 -0
ultradata_math_parser/mmltex/cmarkup.xsl +1093 -0
ultradata_math_parser/mmltex/entities.xsl +316 -0
ultradata_math_parser/mmltex/glayout.xsl +220 -0
ultradata_math_parser/mmltex/mmltex.xsl +45 -0
ultradata_math_parser/mmltex/scripts.xsl +292 -0
ultradata_math_parser/mmltex/tables.xsl +130 -0
ultradata_math_parser/mmltex/tokens.xsl +296 -0
ultradata_math_parser/parsers/__init__.py +15 -0
ultradata_math_parser/parsers/article_parser.py +76 -0
ultradata_math_parser/parsers/base_parser.py +1059 -0
ultradata_math_parser/parsers/custom_parser.py +64 -0
ultradata_math_parser/parsers/forum_parser.py +135 -0
ultradata_math_parser/parsers/title_parser.py +49 -0
ultradata_math_parser/parsers/unified_parser.py +187 -0
ultradata_math_parser/readability_plus.py +539 -0
ultradata_math_parser/utils.py +499 -0

app.py ADDED Viewed

	@@ -0,0 +1,373 @@

+# -*- coding: utf-8 -*-
+"""
+UltraData Math Parser - Hugging Face Space Demo
+A unified HTML parser optimized for extracting mathematical content.
+"""
+import gradio as gr
+from ultradata_math_parser.parsers.unified_parser import UnifiedParser
+def parse_html(
+    html_content: str,
+    base_url: str = "",
+    process_math: bool = True,
+    include_tables: bool = True,
+    enable_forum_assembly: bool = True,
+) -> dict:
+    """
+    Parse HTML content using UnifiedParser.
+    Args:
+        html_content: Raw HTML string to parse
+        base_url: Base URL for resolving relative links
+        process_math: Whether to process and convert math expressions
+        include_tables: Whether to preserve table elements
+        enable_forum_assembly: Whether to enable forum post assembly
+    Returns:
+        Dictionary containing parsed results
+    """
+    if not html_content or not html_content.strip():
+        return {
+            "title": "",
+            "html": "",
+            "text_length": 0,
+            "xp_num": "",
+            "fallback_strategy": "",
+            "forum_assembled": False,
+            "error": "Please provide HTML content to parse.",
+        }
+    parser = UnifiedParser()
+    try:
+        result = parser.extract(
+            html=html_content,
+            base_url=base_url,
+            process_math=process_math,
+            include_tables=include_tables,
+            enable_forum_assembly=enable_forum_assembly,
+        )
+        return {
+            "title": result.get("title", ""),
+            "html": result.get("html", ""),
+            "text_length": result.get("text_length", 0),
+            "xp_num": result.get("xp_num", ""),
+            "fallback_strategy": result.get("fallback_strategy", ""),
+            "forum_assembled": result.get("forum_assembled", False),
+            "error": None,
+        }
+    except Exception as e:
+        return {
+            "title": "",
+            "html": "",
+            "text_length": 0,
+            "xp_num": "",
+            "fallback_strategy": "",
+            "forum_assembled": False,
+            "error": str(e),
+        }
+def format_output(result: dict) -> tuple:
+    """Format the parser output for Gradio display."""
+    if result.get("error"):
+        return (
+            f"❌ Error: {result['error']}",
+            "",
+            "",
+            "",
+        )
+    # Build metadata string
+    metadata = f"""📊 **Parsing Statistics**
+- **Title**: {result['title'] or 'N/A'}
+- **Text Length**: {result['text_length']} characters
+- **XPath Match**: {result['xp_num']}
+- **Fallback Strategy**: {result['fallback_strategy']}
+- **Forum Assembled**: {'✅ Yes' if result['forum_assembled'] else '❌ No'}
+"""
+    return (
+        metadata,
+        result.get("title", ""),
+        result.get("html", ""),
+        result.get("html", ""),  # For HTML preview
+    )
+def process_input(html_content, base_url, process_math, include_tables, enable_forum):
+    """Main processing function for Gradio interface."""
+    result = parse_html(
+        html_content=html_content,
+        base_url=base_url,
+        process_math=process_math,
+        include_tables=include_tables,
+        enable_forum_assembly=enable_forum,
+    )
+    return format_output(result)
+# Example HTML content for demo
+EXAMPLE_HTML = """<!DOCTYPE html>
+<html>
+<head>
+    <title>Quadratic Formula Example</title>
+</head>
+<body>
+    <article class="post-content">
+        <h1>Understanding the Quadratic Formula</h1>
+        <p>The quadratic formula is used to solve equations of the form ax² + bx + c = 0.</p>
+        <p>The solution is given by:</p>
+        <math xmlns="http://www.w3.org/1998/Math/MathML">
+            <mi>x</mi>
+            <mo>=</mo>
+            <mfrac>
+                <mrow>
+                    <mo>-</mo>
+                    <mi>b</mi>
+                    <mo>±</mo>
+                    <msqrt>
+                        <mrow>
+                            <msup><mi>b</mi><mn>2</mn></msup>
+                            <mo>-</mo>
+                            <mn>4</mn>
+                            <mi>a</mi>
+                            <mi>c</mi>
+                        </mrow>
+                    </msqrt>
+                </mrow>
+                <mrow>
+                    <mn>2</mn>
+                    <mi>a</mi>
+                </mrow>
+            </mfrac>
+        </math>
+        <p>Where a, b, and c are coefficients of the quadratic equation.</p>
+        <h2>Example Problem</h2>
+        <p>Solve: x² - 5x + 6 = 0</p>
+        <p>Here, a = 1, b = -5, c = 6</p>
+        <p>Using the formula: x = (5 ± √(25-24))/2 = (5 ± 1)/2</p>
+        <p>Therefore, x = 3 or x = 2</p>
+    </article>
+    <footer>
+        <nav>Related articles...</nav>
+    </footer>
+</body>
+</html>"""
+# Custom CSS for better aesthetics
+custom_css = """
+@import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500&family=Space+Grotesk:wght@400;500;600;700&display=swap');
+.gradio-container {
+    font-family: 'Space Grotesk', sans-serif !important;
+    background: linear-gradient(135deg, #0f0f23 0%, #1a1a3e 50%, #0f0f23 100%) !important;
+    min-height: 100vh;
+}
+.main-title {
+    font-family: 'Space Grotesk', sans-serif !important;
+    font-weight: 700 !important;
+    font-size: 2.5rem !important;
+    background: linear-gradient(90deg, #00d4ff, #7c3aed, #f472b6) !important;
+    -webkit-background-clip: text !important;
+    -webkit-text-fill-color: transparent !important;
+    background-clip: text !important;
+    text-align: center !important;
+    margin-bottom: 0.5rem !important;
+}
+.subtitle {
+    text-align: center !important;
+    color: #94a3b8 !important;
+    font-size: 1.1rem !important;
+    margin-bottom: 2rem !important;
+}
+.gr-box {
+    border-radius: 12px !important;
+    border: 1px solid rgba(124, 58, 237, 0.3) !important;
+    background: rgba(15, 15, 35, 0.8) !important;
+    backdrop-filter: blur(10px) !important;
+}
+.gr-input, .gr-textarea {
+    font-family: 'JetBrains Mono', monospace !important;
+    background: rgba(30, 30, 60, 0.6) !important;
+    border: 1px solid rgba(124, 58, 237, 0.4) !important;
+    border-radius: 8px !important;
+    color: #e2e8f0 !important;
+}
+.gr-button-primary {
+    background: linear-gradient(135deg, #7c3aed 0%, #00d4ff 100%) !important;
+    border: none !important;
+    font-weight: 600 !important;
+    font-size: 1rem !important;
+    padding: 12px 32px !important;
+    border-radius: 8px !important;
+    transition: all 0.3s ease !important;
+    text-transform: uppercase !important;
+    letter-spacing: 1px !important;
+}
+.gr-button-primary:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 8px 25px rgba(124, 58, 237, 0.4) !important;
+}
+.gr-button-secondary {
+    background: transparent !important;
+    border: 2px solid rgba(124, 58, 237, 0.5) !important;
+    color: #a78bfa !important;
+    font-weight: 500 !important;
+    border-radius: 8px !important;
+}
+.section-header {
+    color: #00d4ff !important;
+    font-weight: 600 !important;
+    font-size: 1.2rem !important;
+    margin-bottom: 1rem !important;
+    padding-bottom: 0.5rem !important;
+    border-bottom: 2px solid rgba(0, 212, 255, 0.3) !important;
+}
+.output-box {
+    background: rgba(20, 20, 45, 0.9) !important;
+    border: 1px solid rgba(0, 212, 255, 0.3) !important;
+    border-radius: 12px !important;
+    padding: 1rem !important;
+}
+.gr-markdown {
+    color: #e2e8f0 !important;
+}
+.gr-markdown code {
+    background: rgba(124, 58, 237, 0.2) !important;
+    padding: 2px 6px !important;
+    border-radius: 4px !important;
+    font-family: 'JetBrains Mono', monospace !important;
+}
+footer {
+    display: none !important;
+}
+.gr-accordion {
+    border: 1px solid rgba(124, 58, 237, 0.3) !important;
+    border-radius: 8px !important;
+    background: rgba(20, 20, 45, 0.6) !important;
+}
+.gr-check-radio {
+    accent-color: #7c3aed !important;
+}
+label {
+    color: #cbd5e1 !important;
+}
+"""
+# Build Gradio interface
+with gr.Blocks(css=custom_css, title="UltraData Math Parser") as demo:
+    gr.HTML('<h1 class="main-title">📐 UltraData Math Parser</h1>')
+    gr.HTML('<p class="subtitle">Unified HTML Parser for Mathematical Content Extraction</p>')
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.HTML('<div class="section-header">📥 Input</div>')
+            html_input = gr.Textbox(
+                label="HTML Content",
+                placeholder="Paste your HTML content here...",
+                lines=15,
+                max_lines=30,
+                value=EXAMPLE_HTML,
+            )
+            base_url_input = gr.Textbox(
+                label="Base URL (Optional)",
+                placeholder="https://example.com/page",
+                lines=1,
+            )
+            with gr.Accordion("⚙️ Advanced Options", open=False):
+                process_math = gr.Checkbox(
+                    label="Process Math Expressions",
+                    value=True,
+                    info="Convert MathML and LaTeX to unified format",
+                )
+                include_tables = gr.Checkbox(
+                    label="Include Tables",
+                    value=True,
+                    info="Preserve table elements in output",
+                )
+                enable_forum = gr.Checkbox(
+                    label="Enable Forum Assembly",
+                    value=True,
+                    info="Assemble forum posts and comments",
+                )
+            with gr.Row():
+                parse_btn = gr.Button("🚀 Parse HTML", variant="primary", size="lg")
+                clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="lg")
+        with gr.Column(scale=1):
+            gr.HTML('<div class="section-header">📤 Output</div>')
+            metadata_output = gr.Markdown(
+                label="Parsing Statistics",
+                elem_classes=["output-box"],
+            )
+            title_output = gr.Textbox(
+                label="Extracted Title",
+                lines=1,
+                interactive=False,
+            )
+            with gr.Tabs():
+                with gr.TabItem("📝 Raw HTML"):
+                    html_output = gr.Textbox(
+                        label="Extracted HTML",
+                        lines=12,
+                        max_lines=20,
+                        interactive=False,
+                    )
+                with gr.TabItem("👁️ Preview"):
+                    preview_output = gr.HTML(
+                        label="HTML Preview",
+                    )
+    # Event handlers
+    parse_btn.click(
+        fn=process_input,
+        inputs=[html_input, base_url_input, process_math, include_tables, enable_forum],
+        outputs=[metadata_output, title_output, html_output, preview_output],
+    )
+    def clear_all():
+        return "", "", "", "", "", ""
+    clear_btn.click(
+        fn=clear_all,
+        outputs=[html_input, base_url_input, metadata_output, title_output, html_output, preview_output],
+    )
+    # Footer info
+    gr.HTML("""
+    <div style="text-align: center; margin-top: 2rem; padding: 1rem; color: #64748b; font-size: 0.9rem;">
+        <p>🔬 <strong>UltraData Math Parser</strong> - Part of the UltraData-Math Project</p>
+        <p>Specialized in extracting mathematical content from web pages with MathML, LaTeX, and formula support.</p>
+    </div>
+    """)
+if __name__ == "__main__":
+    demo.launch()

requirements.txt ADDED Viewed

	@@ -0,0 +1,9 @@

+gradio>=4.0.0
+Brotli
+cchardet==2.2.0a2
+charset_normalizer
+lxml<5.2.0
+numpy
+py_asciimath
+urllib3
+tldextract

ultradata_math_parser/__init__.py ADDED Viewed

	@@ -0,0 +1,109 @@

+# -*- coding: utf-8 -*-
+import json
+import logging
+from typing import Optional, Type
+from urllib.parse import urlparse
+import tldextract
+from ultradata_math_parser.parsers.article_parser import ArticleParser
+from ultradata_math_parser.parsers.forum_parser import ForumParser
+from ultradata_math_parser.parsers.custom_parser import CustomParser
+from ultradata_math_parser.parsers.unified_parser import UnifiedParser
+from ultradata_math_parser.utils import text_len, run_w3m_dump, W3MError
+from ultradata_math_parser.config import URL_PATTERNS_TO_HTML_TYPE, BUILTIN_SITE_RULES
+class GeneralParser:
+    def __init__(self, config_path="", w3m_path: str = "w3m"):
+        self.logger = logging.getLogger(__name__)
+        if config_path:
+            try:
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    self.rule = json.loads(f.read())
+            except:
+                pass
+        else:
+            self.rule = {}
+        self.w3m_path = w3m_path or "w3m"
+        self.tld_extractor = tldextract.TLDExtract()
+    def extract(self, html="", w3m_path: Optional[str] = None, **kwargs) -> dict:
+        base_url = kwargs.get("base_url", "")
+        netloc = urlparse(base_url).netloc if base_url else ""
+        html_type = kwargs.pop("html_type", None)
+        current_w3m_path = w3m_path or self.w3m_path
+        # 检查 URL 是否匹配内置规则
+        if base_url and self._quick_check_builtin_rules(base_url):
+            try:
+                extracted = self.tld_extractor(base_url)
+                domain = f"{extracted.domain}.{extracted.suffix}"
+                self.logger.debug("TLD Extract result for %s: domain=%s, suffix=%s -> key=%s", base_url, extracted.domain, extracted.suffix, domain)
+                if domain in BUILTIN_SITE_RULES:
+                    try:
+                        builtin_rule = BUILTIN_SITE_RULES[domain]
+                        new_kwargs = dict()
+                        new_kwargs["rule"] = builtin_rule
+                        new_kwargs.update(kwargs)
+                        self.logger.debug("Using builtin rule for domain: %s", domain)
+                        return self._run_extractor(CustomParser, html, new_kwargs, w3m_path=current_w3m_path)
+                    except Exception as exc:
+                        self.logger.debug("Builtin rule extractor failed for %s: %s", domain, exc)
+            except Exception as e:
+                self.logger.debug("Error extracting domain or checking builtin rules: %s", e)
+        # 检查 URL 类型模式
+        if not html_type and base_url:
+            for pattern, type in URL_PATTERNS_TO_HTML_TYPE.items():
+                if pattern in base_url:
+                    html_type = type
+                    break
+        # 使用用户配置的规则
+        if netloc in self.rule:
+            try:
+                new_kwargs = dict()
+                new_kwargs["rule"] = self.rule[netloc]
+                new_kwargs.update(kwargs)
+                return self._run_extractor(CustomParser, html, new_kwargs, w3m_path=current_w3m_path)
+            except Exception as exc:
+                self.logger.debug("Custom extractor failed for %s: %s", netloc, exc)
+        # 根据 html_type 选择提取模式
+        if html_type == "forum":
+            return self._run_extractor(ForumParser, html, kwargs, w3m_path=current_w3m_path)
+        if html_type == "article":
+            return self._run_extractor(ArticleParser, html, kwargs, w3m_path=current_w3m_path)
+        if html_type == "unified":
+            return self._run_extractor(UnifiedParser, html, kwargs, w3m_path=current_w3m_path)
+        # 默认使用统一模式
+        return self._run_extractor(UnifiedParser, html, kwargs, w3m_path=current_w3m_path)
+    def _quick_check_builtin_rules(self, url: str) -> bool:
+        if not url:
+            return False
+        url_lower = url.lower()
+        for domain in BUILTIN_SITE_RULES:
+            if domain in url_lower:
+                return True
+        return False
+    def _run_extractor(self, extractor_cls: Type, html: str, kwargs: dict, w3m_path: str):
+        result = extractor_cls().extract(html=html, **dict(kwargs))
+        return self._apply_w3m(result, w3m_path=w3m_path)
+    def _apply_w3m(self, result: Optional[dict], w3m_path: str) -> Optional[dict]:
+        if not result:
+            return result
+        html_fragment = result.get("html")
+        if not html_fragment:
+            raise RuntimeError("Extraction result does not contain 'html' for w3m")
+        text = run_w3m_dump(html_fragment, w3m_path)
+        enriched = dict(result)
+        enriched["text"] = text
+        enriched["w3m_text"] = text
+        enriched["text_length"] = text_len(text)
+        return enriched

ultradata_math_parser/config.py ADDED Viewed

	@@ -0,0 +1,332 @@

+# -*- coding:utf-8 -*-
+Unique_ID = "ultradata_math_parser_id_internal"
+PAYWALL_DISCARD_XPATH = [
+    """.//*[(self::div or self::p)][
+    contains(@id, "paywall") or contains(@id, "premium") or
+    contains(@class, "paid-content") or contains(@class, "paidcontent") or
+    contains(@class, "obfuscated") or contains(@class, "blurred") or
+    contains(@class, "restricted") or contains(@class, "overlay")
+    ]""",
+]
+OVERALL_DISCARD_XPATH = [
+    # navigation + footers, news outlets related posts, sharing, jp-post-flair jp-relatedposts
+    """.//*[(self::div or self::item or self::ul
+             or self::p or self::section or self::span)][
+    contains(translate(@id, "F","f"), "footer") or contains(translate(@class, "F","f"), "footer")
+    or contains(@id, "related") or contains(translate(@class, "R", "r"), "related") or
+    contains(@id, "viral") or contains(@class, "viral") or
+    starts-with(@id, "shar") or starts-with(@class, "shar") or
+    contains(@class, "share-") or
+    contains(translate(@id, "S", "s"), "share") or
+    contains(@id, "social") or contains(@class, "social") or contains(@class, "sociable") or
+    contains(@id, "syndication") or contains(@class, "syndication") or
+    starts-with(@id, "jp-") or starts-with(@id, "dpsp-content") or
+    contains(@class, "embedded") or contains(@class, "embed")
+    or contains(@id, "newsletter") or contains(@class, "newsletter")
+    or contains(@class, "subnav") or
+    contains(@id, "cookie") or contains(@class, "cookie") or contains(@id, "tags")
+    or contains(@class, "tags")  or contains(@id, "sidebar") or
+    contains(@class, "sidebar") or contains(@id, "banner") or contains(@class, "banner")
+    or contains(@class, "meta") or
+    contains(@id, "menu") or contains(@class, "menu") or
+    contains(translate(@id, "N", "n"), "nav") or contains(translate(@role, "N", "n"), "nav")
+    or starts-with(@class, "nav") or contains(translate(@class, "N", "n"), "navigation") or
+    contains(@class, "navbar") or contains(@class, "navbox") or starts-with(@class, "post-nav")
+    or contains(@id, "breadcrumb") or contains(@class, "breadcrumb") or
+    contains(@id, "bread-crumb") or contains(@class, "bread-crumb") or
+    contains(@id, "author") or contains(@class, "author") or
+    contains(@id, "button") or contains(@class, "button")
+    or contains(translate(@class, "B", "b"), "byline")
+    or contains(@class, "rating") or starts-with(@class, "widget") or
+    contains(@class, "attachment") or contains(@class, "timestamp") or
+    contains(@class, "user-info") or contains(@class, "user-profile") or
+    contains(@class, "-ad-") or contains(@class, "-icon")
+    or contains(@class, "article-infos") or
+    contains(translate(@class, "I", "i"), "infoline")
+    or contains(@data-component, "MostPopularStories")
+    or contains(@class, "outbrain") or contains(@class, "taboola")
+    or contains(@class, "criteo") or contains(@class, "options")
+    or contains(@class, "consent") or contains(@class, "modal-content")
+    or contains(@class, "paid-content") or contains(@class, "paidcontent")
+    or contains(@id, "premium-") or contains(@id, "paywall")
+    or contains(@class, "obfuscated") or contains(@class, "blurred")
+    or contains(@class, " ad ")
+    or contains(@class, "next-post")
+    or contains(@class, "yin") or contains(@class, "zlylin") or
+    contains(@class, "xg1") or contains(@id, "bmdh")
+    or @data-lp-replacement-content]""",
+    # hidden parts
+    """.//*[starts-with(@class, "hide-") or contains(@class, "hide-print") or contains(@id, "hidden")
+    or contains(@style, "hidden") or contains(@hidden, "hidden") or contains(@class, "noprint")
+    or contains(@style, "display:none") or contains(@class, " hidden") or @aria-hidden="true"
+    or contains(@class, "notloaded")]""",
+    # comment debris
+    # or contains(@class, "message-container") or contains(@id, "message_container")
+    """.//*[@class="comments-title" or contains(@class, "comments-title") or
+    contains(@class, "nocomments") or starts-with(@id, "reply-") or starts-with(@class, "reply-") or
+    contains(@class, "-reply-") or contains(@class, "message") or contains(@id, "message_container")
+    or contains(@id, "akismet") or contains(@class, "akismet")] """,
+]
+TEASER_DISCARD_XPATH = [
+    """.//*[(self::div or self::item or self::ul
+             or self::p or self::section or self::span)][
+        contains(translate(@id, "T", "t"), "teaser") or contains(translate(@class, "T", "t"), "teaser")
+    ]""",
+]
+PRECISION_DISCARD_XPATH = [
+    ".//header",
+    """.//*[(self::div or self::item or self::ul
+             or self::p or self::section or self::span)][
+        contains(@id, "bottom") or contains(@class, "bottom") or
+        contains(@id, "link") or contains(@class, "link")
+        or contains(@style, "border")
+    ]""",
+]
+DISCARD_IMAGE_ELEMENTS = [
+    """.//*[(self::div or self::item or self::ul
+             or self::p or self::section or self::span)][
+             contains(@id, "caption") or contains(@class, "caption")
+            ]
+    """
+]
+REMOVE_COMMENTS_XPATH = [
+    """.//*[(self::div or self::ul or self::section)][
+    starts-with(translate(@id, "C","c"), 'comment') or
+    starts-with(translate(@class, "C","c"), 'comment') or starts-with(translate(@name, "C","c"), 'comment') or
+    contains(@class, 'article-comments') or contains(@class, 'post-comments')
+    or starts-with(@id, 'comol') or starts-with(@id, 'disqus_thread')
+    or starts-with(@id, 'dsq-comments')
+    ]"""
+]
+CONTENT_EXTRACTOR_NOISE_XPATHS = [
+    # '//div[contains(@class, "comment") or contains(@name, "comment") or contains(@id, "comment")]',
+    '//div[starts-with(@class, "advert") or starts-with(@name, "advert") or starts-with(@id, "advert")]',
+    '//div[contains(@style, "display: none")]',
+    '//div[contains(@style, "display:none")]',
+]
+# 保留图片，音频，视频
+MANUALLY_CLEANED = [
+    "aside",
+    "embed",
+    "footer",
+    "head",
+    "iframe",
+    "menu",
+    "object",
+    "script",
+    "applet",
+    "canvas",
+    "map",
+    "svg",
+    "area",
+    "blink",
+    "button",
+    "datalist",
+    "dialog",
+    "frame",
+    "frameset",
+    "fieldset",
+    "hr",
+    "link",
+    "input",
+    "ins",
+    "label",
+    "legend",
+    "marquee",
+    "menuitem",
+    "nav",
+    "noscript",
+    "optgroup",
+    "option",
+    "output",
+    "param",
+    "progress",
+    "rp",
+    "rt",
+    "rtc",
+    "select",
+    "style",
+    "track",
+    "textarea",
+    "time",
+    "use",
+]
+MANUALLY_STRIPPED = [
+    "abbr",
+    "acronym",
+    "address",
+    "bdi",
+    "bdo",
+    "big",
+    "cite",
+    "data",
+    "dfn",
+    "font",
+    "hgroup",
+    "ins",
+    "mark",
+    "meta",
+    "ruby",
+    "small",
+    "tbody",
+    "template",
+    "tfoot",
+    "thead",
+]
+CUT_EMPTY_ELEMS = {
+    "article",
+    "b",
+    "blockquote",
+    "dd",
+    "div",
+    "dt",
+    "em",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "i",
+    "li",
+    "main",
+    "p",
+    "pre",
+    "q",
+    "section",
+    "span",
+    "strong",
+}
+USELESS_ATTR = [
+    "share",
+    "contribution",
+    "copyright",
+    "copy-right",
+    "disclaimer",
+    "recommend",
+    "related",
+    "footer",
+    "social",
+    "submeta",
+    "report-infor",
+]
+BODY_XPATH = [
+    """.//*[(self::article or self::div or self::main or self::section)][
+    @class="post" or @class="entry" or
+    contains(@class, "post-text") or contains(@class, "post_text") or
+    contains(@class, "post-body") or contains(@class, "post-entry") or contains(@class, "postentry") or
+    contains(@class, "post-content") or contains(@class, "post_content") or
+    contains(@class, "postcontent") or contains(@class, "postContent") or
+    contains(@class, "article-text") or contains(@class, "articletext") or contains(@class, "articleText")
+    or contains(@id, "entry-content") or
+    contains(@class, "entry-content") or contains(@id, "article-content") or
+    contains(@class, "article-content") or contains(@id, "article__content") or
+    contains(@class, "article__content") or contains(@id, "article-body") or
+    contains(@class, "article-body") or contains(@id, "article__body") or
+    contains(@class, "article__body") or @itemprop="articleBody" or
+    contains(translate(@id, "B", "b"), "articlebody") or contains(translate(@class, "B", "b"), "articlebody")
+    or @id="articleContent" or contains(@class, "ArticleContent") or
+    contains(@class, "page-content") or contains(@class, "text-content") or
+    contains(@id, "body-text") or contains(@class, "body-text") or contains(@class, "body-content") or contains(translate(@class, "B", "b"), "textbody") or
+    contains(@class, "article__container") or contains(@id, "art-content") or contains(@class, "art-content")][1]""",
+    "(.//article)[1]",
+    """(.//*[(self::article or self::div or self::main or self::section)][
+    contains(@class, 'post-bodycopy') or
+    contains(@class, 'storycontent') or contains(@class, 'story-content') or
+    @class='postarea' or @class='art-postcontent' or
+    contains(@class, 'theme-content') or contains(@class, 'blog-content') or
+    contains(@class, 'section-content') or contains(@class, 'single-content') or
+    contains(@class, 'single-post') or
+    contains(@class, 'main-column') or contains(@class, 'wpb_text_column') or
+    starts-with(@id, 'primary') or starts-with(@class, 'article ') or @class="text" or
+    @id="article" or @class="cell" or @id="story" or @class="story" or
+    contains(@class, "story-body") or contains(@class, "field-body") or
+    contains(translate(@class, "FULTEX","fultex"), "fulltext")
+    or @role='article'])[1]""",
+    """(.//*[(self::article or self::div or self::main or self::section)][
+    contains(@id, "content-main") or contains(@class, "content-main") or contains(@class, "content_main") or
+    contains(@id, "content-body") or contains(@class, "content-body") or contains(@id, "contentBody")
+    or contains(@class, "content__body") or contains(translate(@id, "CM","cm"), "main-content") or contains(translate(@class, "CM","cm"), "main-content")
+    or contains(translate(@class, "CP","cp"), "page-content") or
+    @id="content" or @class="content"])[1]""",
+    '(.//*[(self::article or self::div or self::section)][starts-with(@class, "main") or starts-with(@id, "main") or starts-with(@role, "main")])[1]|(.//main)[1]',
+]
+Forum_XPATH = [
+    """.//*[(self::article or self::div or self::main or self::section or self::li or self::tr)][
+    contains(@id, 'question') or contains(@class, 'question')]""",
+    """.//*[(self::article or self::div or self::main or self::section or self::li or self::tr)][
+    contains(@id, 'answer') or contains(@class, 'answer')]""",
+    """.//*[(self::article or self::div or self::main or self::section or self::li or self::tr)][
+    contains(@id, 'comment') or contains(@class, 'comment') or contains(@class, 'Comment')]""",
+    """.//*[(self::article or self::div or self::main or self::section or self::li or self::tr)][contains(@class, "message-container") or contains(@id, "message_container") or contains(@class, "Messages_container")]""",
+    """.//*[(self::article or self::div or self::main or self::section or self::p or self::span or self::li or self::tr)][
+    contains(@id, 'comment-content') or contains(@class, 'comment-content') or contains(@class, 'comment-body') or contains(@class, 'comment-body') or contains(@class, "post-reply") or contains(@class, "reply_content") or contains(@class, "reply-content") or contains(@class, "reply_post") or contains(@class, "post-reply") or contains(@id, "reply") or contains(@class, "post-text") or contains(@class, "post_text") or
+    contains(@class, "post-body") or contains(@class, "postbody") or contains(@class, "post-entry") or contains(@class, "postentry") or contains(@component, 'post') or
+    contains(@class, "post-content") or contains(@class, "post_content") or contains(@class, "p_content") or contains(@class, "Post_content") or contains(@class, "message-post") or contains(@class, "js-post")]""",
+    # id 包含post-加数字组成的形式
+    """.//*[(self::article or self::div or self::main or self::section or self::p or self::span or self::li or self::tr)][contains(@id, 'post-') or contains(@id, 'post_')]"""
+]
+METAS = [
+    '//meta[starts-with(@property, "og:title")]/@content',
+    '//meta[starts-with(@name, "og:title")]/@content',
+    '//meta[starts-with(@property, "title")]/@content',
+    '//meta[starts-with(@name, "title")]/@content',
+    '//meta[starts-with(@property, "page:title")]/@content',
+    '//meta[starts-with(@name, "page:title")]/@content',
+]
+URL_PATTERNS_TO_HTML_TYPE = {
+}
+# 内置的网站适配规则（根据 URL 模式匹配，使用 CustomParser）
+BUILTIN_SITE_RULES = {
+    # answers.com 系列网站适配
+    "answers.com": {
+        "clean": [
+            "//script",
+            "//style",
+        ],
+        "title": {
+            "mode": "xpath",
+            "value": "//h1[@property='name']//text() | //h1[contains(@class, 'headline1')]//text()"
+        },
+        "content": {
+            "mode": "xpath",
+            # 只提取答案内容
+            "value": "//div[@property='content'] | //div[contains(@class, 'markdownStyles')]"
+        }
+    },
+}
+SCORING_WEIGHTS = {
+    "content_length": 1.0,
+    "paragraph_quality": 0.0,
+    "link_density": 0.0,
+    "text_density": 0.0,
+    "punctuation_density": 0.0,
+    "structure_completeness": 0.0,
+    "xpath_confidence": 0.0,
+    "noise_elements": 0.0,
+    "code_block_quality": 0.0,
+    "list_structure": 0.0,
+}
+SCORE_THRESHOLDS = {
+    "min_acceptable_score": 3.0,
+    "similar_threshold": 0.5,
+}

ultradata_math_parser/mmltex/cmarkup.xsl ADDED Viewed

	@@ -0,0 +1,1093 @@

+<?xml version='1.0' encoding="UTF-8"?>
+<xsl:stylesheet
+		xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+		xmlns:m="http://www.w3.org/1998/Math/MathML"
+		version='1.0'>
+<!-- ====================================================================== -->
+<!-- $id: tokens.xsl, 2002/22/11 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+<!-- 4.4.1.1 cn -->
+<xsl:template match="m:cn"><xsl:apply-templates/></xsl:template>
+<xsl:template match="m:cn[@type='complex-cartesian']">
+	<xsl:apply-templates select="text()[1]"/>
+  	<xsl:text>+</xsl:text>
+	<xsl:apply-templates select="text()[2]"/>
+	<xsl:text>i</xsl:text>
+</xsl:template>
+<xsl:template match="m:cn[@type='rational']">
+	<xsl:apply-templates select="text()[1]"/>
+	<xsl:text>/</xsl:text>
+	<xsl:apply-templates select="text()[2]"/>
+</xsl:template>
+<xsl:template match="m:cn[@type='integer' and @base!=10]">
+		<xsl:apply-templates/>
+		<xsl:text>_{</xsl:text><xsl:value-of select="@base"/><xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:cn[@type='complex-polar']">
+	<xsl:apply-templates select="text()[1]"/>
+	<xsl:text>e^{i </xsl:text>
+	<xsl:apply-templates select="text()[2]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:cn[@type='e-notation']">
+    <xsl:apply-templates select="text()[1]"/>
+    <xsl:text>E</xsl:text>
+    <xsl:apply-templates select="text()[2]"/>
+</xsl:template>
+<!-- 4.4.1.1 ci 4.4.1.2 csymbol -->
+<xsl:template match="m:ci | m:csymbol">
+	<xsl:choose>
+		<xsl:when test="string-length(normalize-space(text()))>1">
+			<xsl:text>\mathrm{</xsl:text><xsl:apply-templates/><xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise><xsl:apply-templates/></xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<!-- 4.4.2.1 apply 4.4.2.2 reln -->
+<xsl:template match="m:apply | m:reln">
+	<xsl:apply-templates select="*[1]">
+	<!-- <? -->
+		<xsl:with-param name="p" select="10"/>
+	</xsl:apply-templates>
+	<!-- ?> -->
+ 	<xsl:text>(</xsl:text>
+	<xsl:for-each select="*[position()>1]">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="not(position()=last())"><xsl:text>, </xsl:text></xsl:if>
+	</xsl:for-each>
+ 	<xsl:text>)</xsl:text>
+</xsl:template>
+<!-- 4.4.2.3 fn -->
+<xsl:template match="m:fn[m:apply[1]]"> <!-- for m:fn using default rule -->
+	<xsl:text>(</xsl:text><xsl:apply-templates/><xsl:text>)</xsl:text>
+</xsl:template>
+<!-- 4.4.2.4 interval -->
+<xsl:template match="m:interval[*[2]]">
+	<xsl:choose>
+		<xsl:when test="@closure='open' or @closure='open-closed'">
+			<xsl:text>\left(</xsl:text>
+		</xsl:when>
+		<xsl:otherwise><xsl:text>\left[</xsl:text></xsl:otherwise>
+	</xsl:choose>
+	<xsl:apply-templates select="*[1]"/>
+	<xsl:text> , </xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:choose>
+		<xsl:when test="@closure='open' or @closure='closed-open'">
+			<xsl:text>\right)</xsl:text>
+		</xsl:when>
+		<xsl:otherwise><xsl:text>\right]</xsl:text></xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template match="m:interval">
+	<xsl:text>\left\{</xsl:text><xsl:apply-templates/><xsl:text>\right\}</xsl:text>
+</xsl:template>
+<!-- 4.4.2.5 inverse -->
+<xsl:template match="m:apply[*[1][self::m:inverse]]">
+	<xsl:apply-templates select="*[2]"/><xsl:text>^{(-1)}</xsl:text>
+</xsl:template>
+<!-- 4.4.2.6 sep 4.4.2.7 condition -->
+<xsl:template match="m:sep | m:condition"><xsl:apply-templates/></xsl:template>
+<!-- 4.4.2.9 lambda -->
+<xsl:template match="m:lambda">
+	<xsl:text>\mathrm{lambda}\: </xsl:text>
+  	<xsl:apply-templates select="m:bvar/*"/>
+  	<xsl:text>.\: </xsl:text>
+  <xsl:apply-templates select="*[last()]"/>
+</xsl:template>
+<!-- 4.4.2.10 compose -->
+<xsl:template match="m:apply[*[1][self::m:compose]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\circ </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.2.11 ident -->
+<xsl:template match="m:ident"><xsl:text>\mathrm{id}</xsl:text></xsl:template>
+<!-- 4.4.2.12 domain 4.4.2.13 codomain 4.4.2.14 image 4.4.3.21 arg 4.4.3.24 lcm
+		4.4.5.9 grad 4.4.5.10 curl 4.4.9.4 median 4.4.9.5 mode-->
+<xsl:template match="m:domain | m:codomain | m:image | m:arg | m:lcm | m:grad |
+								 m:curl | m:median | m:mode">
+	<xsl:text>\mathop{\mathrm{</xsl:text>
+	<xsl:value-of select="local-name()"/>
+	<xsl:text>}}</xsl:text>
+</xsl:template>
+<!-- 4.4.2.15 domainofapplication -->
+<xsl:template match="m:domainofapplication"/>
+<!-- 4.4.2.16 piecewise -->
+<xsl:template match="m:piecewise">
+	<xsl:text>\begin{cases}</xsl:text>
+	<xsl:apply-templates select="m:piece"/>
+	<xsl:apply-templates select="m:otherwise"/>
+	<xsl:text>\end{cases}</xsl:text>
+</xsl:template>
+<xsl:template match="m:piece">
+		<xsl:apply-templates select="*[1]"/>
+		<xsl:text> &amp; \text{if $</xsl:text>
+		<xsl:apply-templates select="*[2]"/>
+		<xsl:text>$}</xsl:text>
+		<xsl:if test="not(position()=last()) or ../m:otherwise"><xsl:text>\\ </xsl:text></xsl:if>
+</xsl:template>
+<xsl:template match="m:otherwise">
+	<xsl:apply-templates select="*[1]"/>
+	<xsl:text> &amp; \text{otherwise}</xsl:text>
+</xsl:template>
+<!-- 4.4.3.1 quotient -->
+<xsl:template match="m:apply[*[1][self::m:quotient]]">
+	<xsl:text>\left\lfloor\frac{</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>}{</xsl:text>
+	<xsl:apply-templates select="*[3]"/>
+	<xsl:text>}\right\rfloor </xsl:text>
+</xsl:template>
+<!-- 4.4.3.2 factorial -->
+<xsl:template match="m:apply[*[1][self::m:factorial]]">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+	<xsl:text>!</xsl:text>
+</xsl:template>
+<!-- 4.4.3.3 divide -->
+<xsl:template match="m:apply[*[1][self::m:divide]]">
+	<xsl:param name="p" select="0"/>
+  <xsl:param name="this-p" select="3"/>
+  <xsl:if test="$this-p &lt; $p"><xsl:text>\left(</xsl:text></xsl:if>
+  <xsl:text>\frac{</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+<!--		<xsl:with-param name="p" select="$this-p"/>
+	</xsl:apply-templates>-->
+	<xsl:text>}{</xsl:text>
+	<xsl:apply-templates select="*[3]"/>
+<!--    	<xsl:with-param name="p" select="$this-p"/>
+	</xsl:apply-templates>-->
+	<xsl:text>}</xsl:text>
+	<xsl:if test="$this-p &lt; $p"><xsl:text>\right)</xsl:text></xsl:if>
+</xsl:template>
+<!-- 4.4.3.4 max min -->
+<xsl:template match="m:apply[*[1][self::m:max or self::m:min]]">
+	<xsl:text>\</xsl:text>
+	<xsl:value-of select="local-name(*[1])"/>
+	<xsl:text>\{</xsl:text>
+   <xsl:choose>
+		<xsl:when test="m:condition">
+   		<xsl:apply-templates select="*[last()]"/>
+   		<xsl:text>, </xsl:text>
+			<xsl:apply-templates select="m:condition/node()"/>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:for-each select="*[position() &gt; 1]">
+				<xsl:apply-templates select="."/>
+				<xsl:if test="position() !=last()"><xsl:text> , </xsl:text></xsl:if>
+			</xsl:for-each>
+		</xsl:otherwise>
+   </xsl:choose>
+	<xsl:text>\}</xsl:text>
+</xsl:template>
+<!-- 4.4.3.5  minus-->
+<xsl:template match="m:apply[*[1][self::m:minus] and count(*)=2]">
+	<xsl:text>-</xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="5"/>
+	</xsl:apply-templates>
+</xsl:template>
+<xsl:template match="m:apply[*[1][self::m:minus] and count(*)&gt;2]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">-</xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="2"/>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.3.6  plus-->
+<xsl:template match="m:apply[*[1][self::m:plus]]">
+  <xsl:param name="p" select="0"/>
+  <xsl:if test="$p &gt; 2">
+		<xsl:text>(</xsl:text>
+	</xsl:if>
+  <xsl:for-each select="*[position()&gt;1]">
+   <xsl:if test="position() &gt; 1">
+    <xsl:choose>
+      <xsl:when test="self::m:apply[*[1][self::m:times] and
+      *[2][self::m:apply/*[1][self::m:minus] or self::m:cn[not(m:sep) and
+      (number(.) &lt; 0)]]]">-</xsl:when>
+      <xsl:otherwise>+</xsl:otherwise>
+    </xsl:choose>
+   </xsl:if>
+    <xsl:choose>
+      <xsl:when test="self::m:apply[*[1][self::m:times] and
+      *[2][self::m:cn[not(m:sep) and (number(.) &lt;0)]]]">
+			<xsl:value-of select="-(*[2])"/>
+			<xsl:apply-templates select=".">
+		     <xsl:with-param name="first" select="2"/>
+		     <xsl:with-param name="p" select="2"/>
+		   </xsl:apply-templates>
+       </xsl:when>
+      <xsl:when test="self::m:apply[*[1][self::m:times] and
+      *[2][self::m:apply/*[1][self::m:minus]]]">
+				<xsl:apply-templates select="./*[2]/*[2]"/>
+				<xsl:apply-templates select=".">
+					<xsl:with-param name="first" select="2"/>
+					<xsl:with-param name="p" select="2"/>
+				</xsl:apply-templates>
+			</xsl:when>
+			<xsl:otherwise>
+				<xsl:apply-templates select=".">
+					<xsl:with-param name="p" select="2"/>
+				</xsl:apply-templates>
+			</xsl:otherwise>
+		</xsl:choose>
+	</xsl:for-each>
+	<xsl:if test="$p &gt; 2">
+		<xsl:text>)</xsl:text>
+	</xsl:if>
+</xsl:template>
+<!-- 4.4.3.7 power -->
+<xsl:template match="m:apply[*[1][self::m:power]]">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="5"/>
+	</xsl:apply-templates>
+	<xsl:text>^{</xsl:text>
+	<xsl:apply-templates select="*[3]">
+		<xsl:with-param name="p" select="5"/>
+	</xsl:apply-templates>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.3.8 remainder -->
+<xsl:template match="m:apply[*[1][self::m:rem]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">\mod </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.3.9  times-->
+<xsl:template match="m:apply[*[1][self::m:times]]" name="times">
+  <xsl:param name="p" select="0"/>
+  <xsl:param name="first" select="1"/>
+  <xsl:if test="$p &gt; 3"><xsl:text>(</xsl:text></xsl:if>
+  <xsl:for-each select="*[position()&gt;1]">
+		<xsl:if test="position() &gt; 1">
+			<xsl:choose>
+				<xsl:when test="self::m:cn">\times <!-- times --></xsl:when>
+				<xsl:otherwise><!--invisible times--></xsl:otherwise>
+			</xsl:choose>
+		</xsl:if>
+		<xsl:if test="position()&gt;= $first">
+			<xsl:apply-templates select=".">
+				<xsl:with-param name="p" select="3"/>
+			</xsl:apply-templates>
+		</xsl:if>
+	</xsl:for-each>
+  <xsl:if test="$p &gt; 3"><xsl:text>)</xsl:text></xsl:if>
+</xsl:template>
+<!-- 4.4.3.10 root -->
+<xsl:template match="m:apply[*[1][self::m:root]]">
+	<xsl:text>\sqrt</xsl:text>
+	<xsl:if test="m:degree!=2">
+		<xsl:text>[</xsl:text>
+		<xsl:apply-templates select="m:degree/*"/>
+		<xsl:text>]</xsl:text>
+	</xsl:if>
+	<xsl:text>{</xsl:text>
+	<xsl:apply-templates select="*[position()&gt;1 and not(self::m:degree)]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.3.11 gcd -->
+<xsl:template match="m:gcd"><xsl:text>\gcd </xsl:text></xsl:template>
+<!-- 4.4.3.12 and -->
+<xsl:template match="m:apply[*[1][self::m:and]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\land <!-- and --></xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.3.13 or -->
+<xsl:template match="m:apply[*[1][self::m:or]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="3"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\lor </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.3.14 xor -->
+<xsl:template match="m:apply[*[1][self::m:xor]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="3"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\mathop{\mathrm{xor}}</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.3.15 not -->
+<xsl:template match="m:apply[*[1][self::m:not]]">
+	<xsl:text>\neg </xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+<!-- 4.4.3.16 implies -->
+<xsl:template match="m:apply[*[1][self::m:implies]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">\implies </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.3.17 forall 4.4.3.18 exists -->
+<xsl:template match="m:apply[*[1][self::m:forall or self::m:exists]]">
+	<xsl:text>\</xsl:text>
+	<xsl:value-of select="local-name(*[1])"/>
+	<xsl:text> </xsl:text>
+	<xsl:apply-templates select="m:bvar"/>
+	<xsl:if test="m:condition">
+		<xsl:text>, </xsl:text><xsl:apply-templates select="m:condition"/>
+	</xsl:if>
+	<xsl:if test="*[last()][local-name()!='condition'][local-name()!='bvar']">
+		<xsl:text>\colon </xsl:text>
+	  <xsl:apply-templates select="*[last()]"/>
+  </xsl:if>
+</xsl:template>
+<!-- 4.4.3.19 abs -->
+<xsl:template match="m:apply[*[1][self::m:abs]]">
+	<xsl:text>\left|</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>\right|</xsl:text>
+</xsl:template>
+<!-- 4.4.3.20 conjugate -->
+<xsl:template match="m:apply[*[1][self::m:conjugate]]">
+	<xsl:text>\overline{</xsl:text><xsl:apply-templates select="*[2]"/><xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.3.22 real -->
+<xsl:template match="m:real"><xsl:text>\Re </xsl:text></xsl:template>
+<!-- 4.4.3.23 imaginary -->
+<xsl:template match="m:imaginary"><xsl:text>\Im </xsl:text></xsl:template>
+<!-- 4.4.3.25 floor -->
+<xsl:template match="m:apply[*[1][self::m:floor]]">
+	<xsl:text>\lfloor </xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>\rfloor </xsl:text>
+</xsl:template>
+<!-- 4.4.3.25 ceiling -->
+<xsl:template match="m:apply[*[1][self::m:ceiling]]">
+	<xsl:text>\lceil </xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>\rceil </xsl:text>
+</xsl:template>
+<!-- 4.4.4.1 eq -->
+<xsl:template match="m:apply[*[1][self::m:eq]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">=</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.4.2 neq -->
+<xsl:template match="m:apply[*[1][self::m:neq]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\neq </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.4.3 gt -->
+<xsl:template match="m:apply[*[1][self::m:gt]]">
+<xsl:param name="p" select="0"/>
+<xsl:call-template name="infix">
+	<xsl:with-param name="this-p" select="1"/>
+	<xsl:with-param name="p" select="$p"/>
+	<xsl:with-param name="mo">&gt; </xsl:with-param>
+</xsl:call-template>
+</xsl:template>
+<!-- 4.4.4.4 lt -->
+<xsl:template match="m:apply[*[1][self::m:lt]]">
+<xsl:param name="p" select="0"/>
+<xsl:call-template name="infix">
+	<xsl:with-param name="this-p" select="1"/>
+	<xsl:with-param name="p" select="$p"/>
+	<xsl:with-param name="mo">&lt; </xsl:with-param>
+</xsl:call-template>
+</xsl:template>
+<!-- 4.4.4.5 geq -->
+<xsl:template match="m:apply[*[1][self::m:geq]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\ge </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.4.6 leq -->
+<xsl:template match="m:apply[*[1][self::m:leq]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\le </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.4.7 equivalent -->
+<xsl:template match="m:apply[*[1][self::m:equivalent]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\equiv </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.4.8 approx -->
+<xsl:template match="m:apply[*[1][self::m:approx]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="1"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\approx </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.4.9 factorof -->
+<xsl:template match="m:apply[*[1][self::m:factorof]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo"> | </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.5.1 int -->
+<xsl:template match="m:apply[*[1][self::m:int]]">
+	<xsl:text>\int</xsl:text>
+	<xsl:if test="m:lowlimit/*|m:interval/*[1]|m:condition/*">
+		<xsl:text>_{</xsl:text>
+		<xsl:apply-templates select="m:lowlimit/*|m:interval/*[1]|m:condition/*"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="m:uplimit/*|m:interval/*[2]">
+		<xsl:text>^{</xsl:text>
+		<xsl:apply-templates select="m:uplimit/*|m:interval/*[2]"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:text> </xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+	<xsl:text>\,d </xsl:text>
+	<xsl:apply-templates select="m:bvar"/>
+</xsl:template>
+<!-- 4.4.5.2 diff -->
+<xsl:template match="m:apply[*[1][self::m:diff] and m:ci and count(*)=2]" priority="2">
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>^\prime </xsl:text>
+</xsl:template>
+<xsl:template match="m:apply[*[1][self::m:diff]]" priority="1">
+	<xsl:text>\frac{</xsl:text>
+	<xsl:choose>
+		<xsl:when test="m:bvar/m:degree">
+			<xsl:text>d^{</xsl:text>
+			<xsl:apply-templates select="m:bvar/m:degree/node()"/>
+			<xsl:text>}</xsl:text>
+			<xsl:apply-templates select="*[last()]"/>
+			<xsl:text>}{d</xsl:text>
+			<xsl:apply-templates select="m:bvar/node()"/>
+			<xsl:text>^{</xsl:text>
+			<xsl:apply-templates select="m:bvar/m:degree/node()"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>d </xsl:text>
+			<xsl:apply-templates select="*[last()]"/>
+			<xsl:text>}{d </xsl:text>
+			<xsl:apply-templates select="m:bvar"/>
+			<xsl:text>}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.5.3 partialdiff -->
+<xsl:template match="m:apply[*[1][self::m:partialdiff] and m:list and m:ci and count(*)=3]" priority="2">
+	<xsl:text>D_{</xsl:text>
+	<xsl:for-each select="m:list[1]/*">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position()&lt;last()"><xsl:text>, </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:text>}</xsl:text>
+	<xsl:apply-templates select="*[3]"/>
+</xsl:template>
+<xsl:template match="m:apply[*[1][self::m:partialdiff]]" priority="1">
+	<xsl:text>\frac{\partial^{</xsl:text>
+	<xsl:choose>
+		<xsl:when test="m:degree">
+			<xsl:apply-templates select="m:degree/node()"/>
+		</xsl:when>
+		<xsl:when test="m:bvar/m:degree[string(number(.))='NaN']">
+			<xsl:for-each select="m:bvar/m:degree">
+				<xsl:apply-templates select="node()"/>
+				<xsl:if test="position()&lt;last()"><xsl:text>+</xsl:text></xsl:if>
+			</xsl:for-each>
+			<xsl:if test="count(m:bvar[not(m:degree)])&gt;0">
+				<xsl:text>+</xsl:text>
+				<xsl:value-of select="count(m:bvar[not(m:degree)])"/>
+			</xsl:if>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:value-of select="sum(m:bvar/m:degree)+count(m:bvar[not(m:degree)])"/>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:text>}</xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+	<xsl:text>}{</xsl:text>
+	<xsl:for-each select="m:bvar">
+		<xsl:text>\partial </xsl:text>
+		<xsl:apply-templates select="node()"/>
+		<xsl:if test="m:degree">
+			<xsl:text>^{</xsl:text>
+			<xsl:apply-templates select="m:degree/node()"/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+	</xsl:for-each>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.2.8 declare 4.4.5.4 lowlimit 4.4.5.5 uplimit 4.4.5.7 degree 4.4.9.5 momentabout -->
+<xsl:template match="m:declare | m:lowlimit | m:uplimit | m:degree | m:momentabout"/>
+<!-- 4.4.5.6  bvar-->
+<xsl:template match="m:bvar">
+	<xsl:apply-templates/>
+	<xsl:if test="following-sibling::m:bvar"><xsl:text>, </xsl:text></xsl:if>
+</xsl:template>
+<!-- 4.4.5.8 divergence-->
+<xsl:template match="m:divergence"><xsl:text>\mathop{\mathrm{div}}</xsl:text></xsl:template>
+<!-- 4.4.5.11 laplacian-->
+<xsl:template match="m:laplacian"><xsl:text>\nabla^2 </xsl:text></xsl:template>
+<!-- 4.4.6.1 set -->
+<xsl:template match="m:set">
+	<xsl:text>\{</xsl:text><xsl:call-template name="set"/><xsl:text>\}</xsl:text>
+</xsl:template>
+<!-- 4.4.6.2 list -->
+<xsl:template match="m:list">
+	<xsl:text>\left[</xsl:text><xsl:call-template name="set"/><xsl:text>\right]</xsl:text>
+</xsl:template>
+<xsl:template name="set">
+   <xsl:choose>
+		<xsl:when test="m:condition">
+   		<xsl:apply-templates select="m:bvar/*[not(self::bvar or self::condition)]"/>
+   		<xsl:text>\colon </xsl:text>
+			<xsl:apply-templates select="m:condition/node()"/>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:for-each select="*">
+				<xsl:apply-templates select="."/>
+				<xsl:if test="position()!=last()"><xsl:text>, </xsl:text></xsl:if>
+			</xsl:for-each>
+		</xsl:otherwise>
+   </xsl:choose>
+</xsl:template>
+<!-- 4.4.6.3 union -->
+<xsl:template match="m:apply[*[1][self::m:union]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\cup </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.4 intersect -->
+<xsl:template match="m:apply[*[1][self::m:intersect]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="3"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\cap </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.5 in -->
+<xsl:template match="m:apply[*[1][self::m:in]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">\in </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.5 notin -->
+<xsl:template match="m:apply[*[1][self::m:notin]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="mo">\notin </xsl:with-param>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="this-p" select="3"/>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.7 subset -->
+<xsl:template match="m:apply[*[1][self::m:subset]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\subseteq </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.8 prsubset -->
+<xsl:template match="m:apply[*[1][self::m:prsubset]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\subset </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.9 notsubset -->
+<xsl:template match="m:apply[*[1][self::m:notsubset]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\nsubseteq </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.10 notprsubset -->
+<xsl:template match="m:apply[*[1][self::m:notprsubset]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\not\subset </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.11 setdiff -->
+<xsl:template match="m:apply[*[1][self::m:setdiff]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\setminus </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.6.12 card -->
+<xsl:template match="m:apply[*[1][self::m:card]]">
+	<xsl:text>|</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>|</xsl:text>
+</xsl:template>
+<!-- 4.4.6.13 cartesianproduct 4.4.10.6 vectorproduct -->
+<xsl:template match="m:apply[*[1][self::m:cartesianproduct or self::m:vectorproduct]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\times </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<xsl:template
+match="m:apply[*[1][self::m:cartesianproduct][count(following-sibling::m:reals)=count(following-sibling::*)]]"
+priority="2">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="5"/>
+	</xsl:apply-templates>
+	<xsl:text>^{</xsl:text>
+	<xsl:value-of select="count(*)-1"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.7.1 sum -->
+<xsl:template match="m:apply[*[1][self::m:sum]]">
+	<xsl:text>\sum</xsl:text><xsl:call-template name="series"/>
+</xsl:template>
+<!-- 4.4.7.2 product -->
+<xsl:template match="m:apply[*[1][self::m:product]]">
+	<xsl:text>\prod</xsl:text><xsl:call-template name="series"/>
+</xsl:template>
+<xsl:template name="series">
+	<xsl:if test="m:lowlimit/*|m:interval/*[1]|m:condition/*">
+		<xsl:text>_{</xsl:text>
+		<xsl:if test="not(m:condition)">
+			<xsl:apply-templates select="m:bvar"/>
+			<xsl:text>=</xsl:text>
+		</xsl:if>
+		<xsl:apply-templates select="m:lowlimit/*|m:interval/*[1]|m:condition/*"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="m:uplimit/*|m:interval/*[2]">
+		<xsl:text>^{</xsl:text>
+		<xsl:apply-templates select="m:uplimit/*|m:interval/*[2]"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:text> </xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+</xsl:template>
+<!-- 4.4.7.3 limit -->
+<xsl:template match="m:apply[*[1][self::m:limit]]">
+	<xsl:text>\lim_{</xsl:text>
+	<xsl:apply-templates select="m:lowlimit|m:condition/*"/>
+	<xsl:text>}</xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+</xsl:template>
+<xsl:template match="m:apply[m:limit]/m:lowlimit" priority="3">
+	<xsl:apply-templates select="../m:bvar/node()"/>
+	<xsl:text>\to </xsl:text>
+	<xsl:apply-templates/>
+</xsl:template>
+<!-- 4.4.7.4 tendsto -->
+<xsl:template match="m:apply[*[1][self::m:tendsto]]">
+	<xsl:param name="p"/>
+	<xsl:call-template name="binary">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">
+			<xsl:choose>
+				<xsl:when test="@type='above'">\searrow </xsl:when>
+				<xsl:when test="@type='below'">\nearrow </xsl:when>
+				<xsl:when test="@type='two-sided'">\rightarrow </xsl:when>
+				<xsl:otherwise>\to </xsl:otherwise>
+			</xsl:choose>
+		</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.8.1 common tringonometric functions 4.4.8.3 natural logarithm -->
+<xsl:template match="m:apply[*[1][
+ self::m:sin or 		self::m:cos or 	self::m:tan or		self::m:sec or
+ self::m:csc or 		self::m:cot or 	self::m:sinh or	 	self::m:cosh or
+ self::m:tanh or 		self::m:coth or	self::m:arcsin or 	self::m:arccos or
+ self::m:arctan or 	self::m:ln]]">
+	<xsl:text>\</xsl:text>
+	<xsl:value-of select="local-name(*[1])"/>
+	<xsl:text> </xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+<xsl:template match="m:sin | m:cos | m:tan | m:sec | m:csc |
+								 m:cot | m:sinh | m:cosh | m:tanh | m:coth |
+								 m:arcsin | m:arccos | m:arctan | m:ln">
+	<xsl:text>\</xsl:text>
+	<xsl:value-of select="local-name(.)"/>
+	<xsl:text> </xsl:text>
+</xsl:template>
+<xsl:template match="m:apply[*[1][
+ self::m:sech or 		self::m:csch or		self::m:arccosh or
+ self::m:arccot or 	self::m:arccoth or 	self::m:arccsc or
+ self::m:arccsch or self::m:arcsec or 	self::m:arcsech or
+ self::m:arcsinh or self::m:arctanh]]">
+	<xsl:text>\mathrm{</xsl:text>
+	<xsl:value-of select="local-name(*[1])"/>
+	<xsl:text>\,}</xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+<xsl:template match="m:sech | m:csch | m:arccosh | m:arccot |
+								 m:arccoth | m:arccsc |m:arccsch |m:arcsec |
+								 m:arcsech | m:arcsinh | m:arctanh">
+	<xsl:text>\mathrm{</xsl:text>
+	<xsl:value-of select="local-name(.)"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.8.2 exp -->
+<xsl:template match="m:apply[*[1][self::m:exp]]">
+	<xsl:text>e^{</xsl:text><xsl:apply-templates select="*[2]"/><xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.8.4 log -->
+<xsl:template match="m:apply[*[1][self::m:log]]">
+	<xsl:text>\lg </xsl:text>
+	<xsl:apply-templates select="*[last()]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+<xsl:template match="m:apply[*[1][self::m:log] and m:logbase != 10]">
+	<xsl:text>\log_{</xsl:text>
+	<xsl:apply-templates select="m:logbase/node()"/>
+	<xsl:text>}</xsl:text>
+	<xsl:apply-templates select="*[last()]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+<!-- 4.4.9.1 mean -->
+<xsl:template match="m:apply[*[1][self::m:mean]]">
+	<xsl:text>\langle </xsl:text>
+	<xsl:for-each select="*[position()&gt;1]">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position() !=last()"><xsl:text>, </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:text>\rangle </xsl:text>
+</xsl:template>
+<!-- 4.4.9.2 sdef -->
+<xsl:template match="m:sdev"><xsl:text>\sigma </xsl:text></xsl:template>
+<!-- 4.4.9.3 variance -->
+<xsl:template match="m:apply[*[1][self::m:variance]]">
+	<xsl:text>\sigma(</xsl:text>
+	<xsl:apply-templates select="*[2]"/>
+	<xsl:text>)^2</xsl:text>
+</xsl:template>
+<!-- 4.4.9.5 moment -->
+<xsl:template match="m:apply[*[1][self::m:moment]]">
+	<xsl:text>\langle </xsl:text>
+	<xsl:apply-templates select="*[last()]"/>
+	<xsl:text>^{</xsl:text>
+	<xsl:apply-templates select="m:degree/node()"/>
+	<xsl:text>}\rangle</xsl:text>
+	<xsl:if test="m:momentabout">
+		<xsl:text>_{</xsl:text>
+		<xsl:apply-templates select="m:momentabout/node()"/>
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:text> </xsl:text>
+</xsl:template>
+<!-- 4.4.10.1 vector  -->
+<xsl:template match="m:vector">
+	<xsl:text>\left(\begin{array}{c}</xsl:text>
+	<xsl:for-each select="*">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position()!=last()"><xsl:text>\\ </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:text>\end{array}\right)</xsl:text>
+</xsl:template>
+<!-- 4.4.10.2 matrix  -->
+<xsl:template match="m:matrix">
+	<xsl:text>\begin{pmatrix}</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>\end{pmatrix}</xsl:text>
+</xsl:template>
+<!-- 4.4.10.3 matrixrow  -->
+<xsl:template match="m:matrixrow">
+	<xsl:for-each select="*">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position()!=last()"><xsl:text> &amp; </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:if test="position()!=last()"><xsl:text>\\ </xsl:text></xsl:if>
+</xsl:template>
+<!-- 4.4.10.4 determinant  -->
+<xsl:template match="m:apply[*[1][self::m:determinant]]">
+	<xsl:text>\det </xsl:text>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+</xsl:template>
+<xsl:template match="m:apply[*[1][self::m:determinant]][*[2][self::m:matrix]]" priority="2">
+	<xsl:text>\begin{vmatrix}</xsl:text>
+	<xsl:apply-templates select="m:matrix/*"/>
+	<xsl:text>\end{vmatrix}</xsl:text>
+</xsl:template>
+<!-- 4.4.10.5 transpose -->
+<xsl:template match="m:apply[*[1][self::m:transpose]]">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+	<xsl:text>^T</xsl:text>
+</xsl:template>
+<!-- 4.4.10.5 selector -->
+<xsl:template match="m:apply[*[1][self::m:selector]]">
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="7"/>
+	</xsl:apply-templates>
+	<xsl:text>_{</xsl:text>
+	<xsl:for-each select="*[position()&gt;2]">
+		<xsl:apply-templates select="."/>
+		<xsl:if test="position() !=last()"><xsl:text>, </xsl:text></xsl:if>
+	</xsl:for-each>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<!-- 4.4.10.7 scalarproduct 4.4.10.8 outerproduct -->
+<xsl:template match="m:apply[*[1][self::m:scalarproduct or self::m:outerproduct]]">
+	<xsl:param name="p" select="0"/>
+	<xsl:call-template name="infix">
+		<xsl:with-param name="this-p" select="2"/>
+		<xsl:with-param name="p" select="$p"/>
+		<xsl:with-param name="mo">\dot </xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<!-- 4.4.11.2 semantics -->
+<xsl:template match="m:semantics"><xsl:apply-templates select="*[1]"/></xsl:template>
+<xsl:template match="m:semantics[m:annotation/@encoding='TeX']">
+	<xsl:apply-templates select="m:annotation[@encoding='TeX']/node()"/>
+</xsl:template>
+<!-- 4.4.12.1 integers -->
+<xsl:template match="m:integers"><xsl:text>\mathbb{Z}</xsl:text></xsl:template>
+<!-- 4.4.12.2 reals -->
+<xsl:template match="m:reals"><xsl:text>\mathbb{R}</xsl:text></xsl:template>
+<!-- 4.4.12.3 rationals -->
+<xsl:template match="m:rationals"><xsl:text>\mathbb{Q}</xsl:text></xsl:template>
+<!-- 4.4.12.4 naturalnumbers -->
+<xsl:template match="m:naturalnumbers"><xsl:text>\mathbb{N}</xsl:text></xsl:template>
+<!-- 4.4.12.5 complexes -->
+<xsl:template match="m:complexes"><xsl:text>\mathbb{C}</xsl:text></xsl:template>
+<!-- 4.4.12.6 primes -->
+<xsl:template match="m:primes"><xsl:text>\mathbb{P}</xsl:text></xsl:template>
+<!-- 4.4.12.7 exponentiale -->
+<xsl:template match="m:exponentiale"><xsl:text>e</xsl:text></xsl:template>
+<!-- 4.4.12.8 imaginaryi -->
+<xsl:template match="m:imaginaryi"><xsl:text>i</xsl:text></xsl:template>
+<!-- 4.4.12.9 notanumber -->
+<xsl:template match="m:notanumber"><xsl:text>NaN</xsl:text></xsl:template>
+<!-- 4.4.12.10 true -->
+<xsl:template match="m:true"><xsl:text>\mbox{true}</xsl:text></xsl:template>
+<!-- 4.4.12.11 false -->
+<xsl:template match="m:false"><xsl:text>\mbox{false}</xsl:text></xsl:template>
+<!-- 4.4.12.12 emptyset -->
+<xsl:template match="m:emptyset"><xsl:text>\emptyset </xsl:text></xsl:template>
+<!-- 4.4.12.13 pi -->
+<xsl:template match="m:pi"><xsl:text>\pi </xsl:text></xsl:template>
+<!-- 4.4.12.14 eulergamma -->
+<xsl:template match="m:eulergamma"><xsl:text>\gamma </xsl:text></xsl:template>
+<!-- 4.4.12.15 infinity -->
+<xsl:template match="m:infinity"><xsl:text>\infty </xsl:text></xsl:template>
+<!-- ****************************** -->
+<xsl:template name="infix" >
+  <xsl:param name="mo"/>
+  <xsl:param name="p" select="0"/>
+  <xsl:param name="this-p" select="0"/>
+  <xsl:if test="$this-p &lt; $p"><xsl:text>(</xsl:text></xsl:if>
+  <xsl:for-each select="*[position()&gt;1]">
+		<xsl:if test="position() &gt; 1">
+			<xsl:copy-of select="$mo"/>
+		</xsl:if>
+		<xsl:apply-templates select=".">
+			<xsl:with-param name="p" select="$this-p"/>
+		</xsl:apply-templates>
+	</xsl:for-each>
+  <xsl:if test="$this-p &lt; $p"><xsl:text>)</xsl:text></xsl:if>
+</xsl:template>
+<xsl:template name="binary" >
+  <xsl:param name="mo"/>
+  <xsl:param name="p" select="0"/>
+  <xsl:param name="this-p" select="0"/>
+  <xsl:if test="$this-p &lt; $p"><xsl:text>(</xsl:text></xsl:if>
+	<xsl:apply-templates select="*[2]">
+		<xsl:with-param name="p" select="$this-p"/>
+	</xsl:apply-templates>
+	<xsl:value-of select="$mo"/>
+	<xsl:apply-templates select="*[3]">
+    	<xsl:with-param name="p" select="$this-p"/>
+	</xsl:apply-templates>
+	<xsl:if test="$this-p &lt; $p"><xsl:text>)</xsl:text></xsl:if>
+</xsl:template>
+</xsl:stylesheet>

ultradata_math_parser/mmltex/entities.xsl ADDED Viewed

	@@ -0,0 +1,316 @@

+<?xml version='1.0' encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+		xmlns:m="http://www.w3.org/1998/Math/MathML"
+                version='1.0'>
+<!-- ====================================================================== -->
+<!-- $id: entities.xsl, 2002/22/11 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+<xsl:template name="replaceEntities">
+	<xsl:param name="content"/>
+	<xsl:if test="string-length($content)>0">
+	<xsl:choose>
+		<xsl:when test="starts-with($content,'&#x0025B;')"><xsl:value-of select="'\varepsilon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0025B;')"/></xsl:call-template></xsl:when>	<!--/varepsilon -->
+<!-- ====================================================================== -->
+<!-- 	Unicode 3.2
+	Greek
+	Range: 0370-03FF
+	http://www.unicode.org/charts/PDF/U0370.pdf	                    -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x00393;')"><xsl:value-of select="'\Gamma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x00393;')"/></xsl:call-template></xsl:when>	<!--/Gamma capital Gamma, Greek -->
+		<xsl:when test="starts-with($content,'&#x00394;')"><xsl:value-of select="'\Delta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x00394;')"/></xsl:call-template></xsl:when>	<!--/Delta capital Delta, Greek -->
+		<xsl:when test="starts-with($content,'&#x00398;')"><xsl:value-of select="'\Theta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x00398;')"/></xsl:call-template></xsl:when>	<!--/Theta capital Theta, Greek -->
+		<xsl:when test="starts-with($content,'&#x0039B;')"><xsl:value-of select="'\Lambda '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0039B;')"/></xsl:call-template></xsl:when>	<!--/Lambda capital Lambda, Greek -->
+		<xsl:when test="starts-with($content,'&#x0039E;')"><xsl:value-of select="'\Xi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0039E;')"/></xsl:call-template></xsl:when>	<!--/Xi capital Xi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A0;')"><xsl:value-of select="'\Pi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A0;')"/></xsl:call-template></xsl:when>	<!--/Pi capital Pi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A3;')"><xsl:value-of select="'\Sigma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A3;')"/></xsl:call-template></xsl:when>	<!--/Sigma capital Sigma, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A6;')"><xsl:value-of select="'\Phi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A6;')"/></xsl:call-template></xsl:when>	<!--/Phi capital Phi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A8;')"><xsl:value-of select="'\Psi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A8;')"/></xsl:call-template></xsl:when>	<!--/Psi capital Psi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003A9;')"><xsl:value-of select="'\Omega '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003A9;')"/></xsl:call-template></xsl:when>	<!--/Omega capital Omega, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B1;')"><xsl:value-of select="'\alpha '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B1;')"/></xsl:call-template></xsl:when>	<!--/alpha small alpha, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B2;')"><xsl:value-of select="'\beta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B2;')"/></xsl:call-template></xsl:when>	<!--/beta small beta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B3;')"><xsl:value-of select="'\gamma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B3;')"/></xsl:call-template></xsl:when>	<!--/gamma small gamma, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B4;')"><xsl:value-of select="'\delta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B4;')"/></xsl:call-template></xsl:when>	<!--/delta small delta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B5;')"><xsl:value-of select="'\epsilon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B5;')"/></xsl:call-template></xsl:when>	<!--/straightepsilon, small epsilon, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B6;')"><xsl:value-of select="'\zeta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B6;')"/></xsl:call-template></xsl:when>	<!--/zeta small zeta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B7;')"><xsl:value-of select="'\eta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B7;')"/></xsl:call-template></xsl:when>	<!--/eta small eta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B8;')"><xsl:value-of select="'\theta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B8;')"/></xsl:call-template></xsl:when>	<!--/theta straight theta, small theta, Greek -->
+		<xsl:when test="starts-with($content,'&#x003B9;')"><xsl:value-of select="'\iota '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003B9;')"/></xsl:call-template></xsl:when>	<!--/iota small iota, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BA;')"><xsl:value-of select="'\kappa '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BA;')"/></xsl:call-template></xsl:when>	<!--/kappa small kappa, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BB;')"><xsl:value-of select="'\lambda '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BB;')"/></xsl:call-template></xsl:when>	<!--/lambda small lambda, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BC;')"><xsl:value-of select="'\mu '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BC;')"/></xsl:call-template></xsl:when>	<!--/mu small mu, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BD;')"><xsl:value-of select="'\nu '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BD;')"/></xsl:call-template></xsl:when>	<!--/nu small nu, Greek -->
+		<xsl:when test="starts-with($content,'&#x003BE;')"><xsl:value-of select="'\xi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003BE;')"/></xsl:call-template></xsl:when>	<!--/xi small xi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C0;')"><xsl:value-of select="'\pi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C0;')"/></xsl:call-template></xsl:when>	<!--/pi small pi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C1;')"><xsl:value-of select="'\rho '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C1;')"/></xsl:call-template></xsl:when>	<!--/rho small rho, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C2;')"><xsl:value-of select="'\varsigma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C2;')"/></xsl:call-template></xsl:when>	<!--/varsigma -->
+		<xsl:when test="starts-with($content,'&#x003C3;')"><xsl:value-of select="'\sigma '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C3;')"/></xsl:call-template></xsl:when>	<!--/sigma small sigma, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C4;')"><xsl:value-of select="'\tau '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C4;')"/></xsl:call-template></xsl:when>	<!--/tau small tau, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C5;')"><xsl:value-of select="'\upsilon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C5;')"/></xsl:call-template></xsl:when>	<!--/upsilon small upsilon, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C6;')"><xsl:value-of select="'\phi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C6;')"/></xsl:call-template></xsl:when>	<!--/straightphi - small phi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C7;')"><xsl:value-of select="'\chi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C7;')"/></xsl:call-template></xsl:when>	<!--/chi small chi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C8;')"><xsl:value-of select="'\psi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C8;')"/></xsl:call-template></xsl:when>	<!--/psi small psi, Greek -->
+		<xsl:when test="starts-with($content,'&#x003C9;')"><xsl:value-of select="'\omega '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003C9;')"/></xsl:call-template></xsl:when>	<!--/omega small omega, Greek -->
+		<xsl:when test="starts-with($content,'&#x003D1;')"><xsl:value-of select="'\vartheta '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003D1;')"/></xsl:call-template></xsl:when>	<!--/vartheta - curly or open theta -->
+		<xsl:when test="starts-with($content,'&#x003D2;')"><xsl:value-of select="'\Upsilon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003D2;')"/></xsl:call-template></xsl:when>	<!--/Upsilon capital Upsilon, Greek -->
+		<xsl:when test="starts-with($content,'&#x003D5;')"><xsl:value-of select="'\varphi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003D5;')"/></xsl:call-template></xsl:when>	<!--/varphi - curly or open phi -->
+		<xsl:when test="starts-with($content,'&#x003D6;')"><xsl:value-of select="'\varpi '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003D6;')"/></xsl:call-template></xsl:when>		<!--/varpi -->
+		<xsl:when test="starts-with($content,'&#x003F0;')"><xsl:value-of select="'\varkappa '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003F0;')"/></xsl:call-template></xsl:when>	<!--/varkappa -->
+		<xsl:when test="starts-with($content,'&#x003F1;')"><xsl:value-of select="'\varrho '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x003F1;')"/></xsl:call-template></xsl:when>	<!--/varrho -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x0200B;')"><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0200B;')"/></xsl:call-template></xsl:when>						<!--short form of  &InvisibleComma; -->
+		<xsl:when test="starts-with($content,'&#x02026;')"><xsl:value-of select="'\dots '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02026;')"/></xsl:call-template></xsl:when>
+		<xsl:when test="starts-with($content,'&#x02032;')"><xsl:value-of select="'\prime '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02032;')"/></xsl:call-template></xsl:when>		<!--/prime prime or minute -->
+		<xsl:when test="starts-with($content,'&#x02061;')"><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02061;')"/></xsl:call-template></xsl:when>						<!-- ApplyFunction -->
+		<xsl:when test="starts-with($content,'&#x02062;')"><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02062;')"/></xsl:call-template></xsl:when>						<!-- InvisibleTimes -->
+<!-- ====================================================================== -->
+<!-- 	Unicode 3.2
+	Letterlike Symbols
+	Range: 2100-214F
+	http://www.unicode.org/charts/PDF/U2100.pdf	                    -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x0210F;&#x0FE00;')"><xsl:value-of select="'\hbar '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0210F;&#x0FE00;')"/></xsl:call-template></xsl:when>	<!--/hbar - Planck's over 2pi -->
+		<xsl:when test="starts-with($content,'&#x0210F;')"><xsl:value-of select="'\hslash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0210F;')"/></xsl:call-template></xsl:when>	<!--/hslash - variant Planck's over 2pi --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02111;')"><xsl:value-of select="'\Im '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02111;')"/></xsl:call-template></xsl:when>		<!--/Im - imaginary   -->
+		<xsl:when test="starts-with($content,'&#x02113;')"><xsl:value-of select="'\ell '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02113;')"/></xsl:call-template></xsl:when>		<!--/ell - cursive small l -->
+		<xsl:when test="starts-with($content,'&#x02118;')"><xsl:value-of select="'\wp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02118;')"/></xsl:call-template></xsl:when>		<!--/wp - Weierstrass p -->
+		<xsl:when test="starts-with($content,'&#x0211C;')"><xsl:value-of select="'\Re '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0211C;')"/></xsl:call-template></xsl:when>		<!--/Re - real -->
+		<xsl:when test="starts-with($content,'&#x02127;')"><xsl:value-of select="'\mho '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02127;')"/></xsl:call-template></xsl:when>		<!--/mho - conductance -->
+		<xsl:when test="starts-with($content,'&#x02135;')"><xsl:value-of select="'\aleph '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02135;')"/></xsl:call-template></xsl:when>		<!--/aleph aleph, Hebrew -->
+		<xsl:when test="starts-with($content,'&#x02136;')"><xsl:value-of select="'\beth '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02136;')"/></xsl:call-template></xsl:when>		<!--/beth - beth, Hebrew --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02137;')"><xsl:value-of select="'\gimel '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02137;')"/></xsl:call-template></xsl:when>		<!--/gimel - gimel, Hebrew --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02138;')"><xsl:value-of select="'\daleth '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02138;')"/></xsl:call-template></xsl:when>	<!--/daleth - daleth, Hebrew --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02145;')"><xsl:value-of select="'D'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02145;')"/></xsl:call-template></xsl:when>		<!--D for use in differentials, e.g., within integrals -->
+		<xsl:when test="starts-with($content,'&#x02146;')"><xsl:value-of select="'d'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02146;')"/></xsl:call-template></xsl:when>		<!--d for use in differentials, e.g., within integrals -->
+		<xsl:when test="starts-with($content,'&#x02147;')"><xsl:value-of select="'e'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02147;')"/></xsl:call-template></xsl:when>		<!--e use for the exponential base of the natural logarithms -->
+		<xsl:when test="starts-with($content,'&#x02148;')"><xsl:value-of select="'i'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02148;')"/></xsl:call-template></xsl:when>		<!--i for use as a square root of -1 -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x02192;')"><xsl:value-of select="'\to '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02192;')"/></xsl:call-template></xsl:when>		<!--/rightarrow /to A: =rightward arrow -->
+<!-- ====================================================================== -->
+<!-- 	Unicode 3.2
+	Mathematical Operators
+	Range: 2200-22FF
+	http://www.unicode.org/charts/PDF/U2200.pdf                         -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x02200;')"><xsl:value-of select="'\forall '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02200;')"/></xsl:call-template></xsl:when>	<!--/forall for all -->
+		<xsl:when test="starts-with($content,'&#x02201;')"><xsl:value-of select="'\complement '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02201;')"/></xsl:call-template></xsl:when>	<!--/complement - complement sign --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02202;')"><xsl:value-of select="'\partial '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02202;')"/></xsl:call-template></xsl:when>	<!--/partial partial differential -->
+		<xsl:when test="starts-with($content,'&#x02203;')"><xsl:value-of select="'\exists '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02203;')"/></xsl:call-template></xsl:when>	<!--/exists at least one exists -->
+		<xsl:when test="starts-with($content,'&#x02204;')"><xsl:value-of select="'\nexists '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02204;')"/></xsl:call-template></xsl:when>	<!--/nexists - negated exists --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02205;&#x0FE00;')"><xsl:value-of select="'\emptyset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02205;&#x0FE00;')"/></xsl:call-template></xsl:when>	<!--/emptyset - zero, slash -->
+		<xsl:when test="starts-with($content,'&#x02205;')"><xsl:value-of select="'\varnothing '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02205;')"/></xsl:call-template></xsl:when>	<!--/varnothing - circle, slash --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x02206;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02206;')"/></xsl:call-template></xsl:when>-->
+		<xsl:when test="starts-with($content,'&#x02207;')"><xsl:value-of select="'\nabla '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02207;')"/></xsl:call-template></xsl:when>		<!--/nabla del, Hamilton operator -->
+		<xsl:when test="starts-with($content,'&#x02208;')"><xsl:value-of select="'\in '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02208;')"/></xsl:call-template></xsl:when>		<!--/in R: set membership  -->
+		<xsl:when test="starts-with($content,'&#x02209;')"><xsl:value-of select="'\notin '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02209;')"/></xsl:call-template></xsl:when>		<!--/notin N: negated set membership -->
+		<xsl:when test="starts-with($content,'&#x0220B;')"><xsl:value-of select="'\ni '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0220B;')"/></xsl:call-template></xsl:when>		<!--/ni /owns R: contains -->
+		<xsl:when test="starts-with($content,'&#x0220C;')"><xsl:value-of select="'\not\ni '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0220C;')"/></xsl:call-template></xsl:when>	<!--negated contains -->
+		<xsl:when test="starts-with($content,'&#x0220F;')"><xsl:value-of select="'\prod '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0220F;')"/></xsl:call-template></xsl:when>		<!--/prod L: product operator -->
+		<xsl:when test="starts-with($content,'&#x02210;')"><xsl:value-of select="'\coprod '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02210;')"/></xsl:call-template></xsl:when>	<!--/coprod L: coproduct operator -->
+		<xsl:when test="starts-with($content,'&#x02211;')"><xsl:value-of select="'\sum '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02211;')"/></xsl:call-template></xsl:when>		<!--/sum L: summation operator -->
+		<xsl:when test="starts-with($content,'&#x02212;')"><xsl:value-of select="'-'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02212;')"/></xsl:call-template></xsl:when>		<!--B: minus sign -->
+		<xsl:when test="starts-with($content,'&#x02213;')"><xsl:value-of select="'\mp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02213;')"/></xsl:call-template></xsl:when>		<!--/mp B: minus-or-plus sign -->
+		<xsl:when test="starts-with($content,'&#x02214;')"><xsl:value-of select="'\dotplus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02214;')"/></xsl:call-template></xsl:when>	<!--/dotplus B: plus sign, dot above --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x02215;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02215;')"/></xsl:call-template></xsl:when>-->
+		<xsl:when test="starts-with($content,'&#x02216;')"><xsl:value-of select="'\setminus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02216;')"/></xsl:call-template></xsl:when>	<!--/setminus B: reverse solidus -->
+		<xsl:when test="starts-with($content,'&#x02217;')"><xsl:value-of select="'\ast '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02217;')"/></xsl:call-template></xsl:when>		<!--low asterisk -->
+		<xsl:when test="starts-with($content,'&#x02218;')"><xsl:value-of select="'\circ '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02218;')"/></xsl:call-template></xsl:when>		<!--/circ B: composite function (small circle) -->
+		<xsl:when test="starts-with($content,'&#x02219;')"><xsl:value-of select="'\bullet '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02219;')"/></xsl:call-template></xsl:when>
+		<xsl:when test="starts-with($content,'&#x0221A;')"><xsl:value-of select="'\surd '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0221A;')"/></xsl:call-template></xsl:when>		<!--/surd radical -->
+		<xsl:when test="starts-with($content,'&#x0221D;')"><xsl:value-of select="'\propto '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0221D;')"/></xsl:call-template></xsl:when>	<!--/propto R: is proportional to -->
+		<xsl:when test="starts-with($content,'&#x0221E;')"><xsl:value-of select="'\infty '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0221E;')"/></xsl:call-template></xsl:when>		<!--/infty infinity -->
+<!--		<xsl:when test="starts-with($content,'&#x0221F;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0221F;')"/></xsl:call-template></xsl:when>		right (90 degree) angle -->
+		<xsl:when test="starts-with($content,'&#x02220;')"><xsl:value-of select="'\angle '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02220;')"/></xsl:call-template></xsl:when>		<!--/angle - angle -->
+		<xsl:when test="starts-with($content,'&#x02221;')"><xsl:value-of select="'\measuredangle '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02221;')"/></xsl:call-template></xsl:when>	<!--/measuredangle - angle-measured -->	<!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02222;')"><xsl:value-of select="'\sphericalangle '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02222;')"/></xsl:call-template></xsl:when><!--/sphericalangle angle-spherical -->	<!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02223;')"><xsl:value-of select="'\mid '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02223;')"/></xsl:call-template></xsl:when>		<!--/mid R: -->
+		<xsl:when test="starts-with($content,'&#x02224;&#x0FE00;')"><xsl:value-of select="'\nshortmid '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02224;&#x0FE00;')"/></xsl:call-template></xsl:when>	<!--/nshortmid --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02224;')"><xsl:value-of select="'\nmid '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02224;')"/></xsl:call-template></xsl:when>		<!--/nmid --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02225;')"><xsl:value-of select="'\parallel '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02225;')"/></xsl:call-template></xsl:when>	<!--/parallel R: parallel -->
+		<xsl:when test="starts-with($content,'&#x02226;&#x0FE00;')"><xsl:value-of select="'\nshortparallel '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02226;&#x0FE00;')"/></xsl:call-template></xsl:when>	<!--/nshortparallel N: not short par --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02226;')"><xsl:value-of select="'\nparallel '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02226;')"/></xsl:call-template></xsl:when>	<!--/nparallel N: not parallel --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02227;')"><xsl:value-of select="'\wedge '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02227;')"/></xsl:call-template></xsl:when>		<!--/wedge /land B: logical and -->
+		<xsl:when test="starts-with($content,'&#x02228;')"><xsl:value-of select="'\vee '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02228;')"/></xsl:call-template></xsl:when>		<!--/vee /lor B: logical or -->
+		<xsl:when test="starts-with($content,'&#x02229;')"><xsl:value-of select="'\cap '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02229;')"/></xsl:call-template></xsl:when>		<!--/cap B: intersection -->
+		<xsl:when test="starts-with($content,'&#x0222A;')"><xsl:value-of select="'\cup '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222A;')"/></xsl:call-template></xsl:when>		<!--/cup B: union or logical sum -->
+		<xsl:when test="starts-with($content,'&#x0222B;')"><xsl:value-of select="'\int '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222B;')"/></xsl:call-template></xsl:when>		<!--/int L: integral operator -->
+		<xsl:when test="starts-with($content,'&#x0222C;')"><xsl:value-of select="'\iint '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222C;')"/></xsl:call-template></xsl:when>		<!--double integral operator --> <!-- Required amsmath -->
+		<xsl:when test="starts-with($content,'&#x0222D;')"><xsl:value-of select="'\iiint '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222D;')"/></xsl:call-template></xsl:when>		<!--/iiint triple integral operator -->	<!-- Required amsmath -->
+		<xsl:when test="starts-with($content,'&#x0222E;')"><xsl:value-of select="'\oint '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222E;')"/></xsl:call-template></xsl:when>		<!--/oint L: contour integral operator -->
+<!--		<xsl:when test="starts-with($content,'&#x0222F;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0222F;')"/></xsl:call-template></xsl:when>-->
+<!--		<xsl:when test="starts-with($content,'&#x02230;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02230;')"/></xsl:call-template></xsl:when>-->
+<!--		<xsl:when test="starts-with($content,'&#x02231;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02231;')"/></xsl:call-template></xsl:when>-->
+<!--		<xsl:when test="starts-with($content,'&#x02232;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02232;')"/></xsl:call-template></xsl:when>-->
+<!--		<xsl:when test="starts-with($content,'&#x02233;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02233;')"/></xsl:call-template></xsl:when>-->
+		<xsl:when test="starts-with($content,'&#x02234;')"><xsl:value-of select="'\therefore '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02234;')"/></xsl:call-template></xsl:when>	<!--/therefore R: therefore --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02235;')"><xsl:value-of select="'\because '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02235;')"/></xsl:call-template></xsl:when>	<!--/because R: because --> <!-- Required amssymb -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02236;')"><xsl:value-of select="':'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02236;')"/></xsl:call-template></xsl:when>		<!--/ratio -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02237;')"><xsl:value-of select="'\colon\colon '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02237;')"/></xsl:call-template></xsl:when>	<!--/Colon, two colons -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02238;')"><xsl:value-of select="'\dot{-}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02238;')"/></xsl:call-template></xsl:when>		<!--/dotminus B: minus sign, dot above -->
+<!--		<xsl:when test="starts-with($content,'&#x02239;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02239;')"/></xsl:call-template></xsl:when>		-->
+<!--		<xsl:when test="starts-with($content,'&#x0223A;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223A;')"/></xsl:call-template></xsl:when>		minus with four dots, geometric properties -->
+<!--		<xsl:when test="starts-with($content,'&#x0223B;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223B;')"/></xsl:call-template></xsl:when>		homothetic -->
+		<xsl:when test="starts-with($content,'&#x0223C;')"><xsl:value-of select="'\sim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223C;')"/></xsl:call-template></xsl:when>		<!--/sim R: similar -->
+		<xsl:when test="starts-with($content,'&#x0223D;')"><xsl:value-of select="'\backsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223D;')"/></xsl:call-template></xsl:when>	<!--/backsim R: reverse similar --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x0223E;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223E;')"/></xsl:call-template></xsl:when>		most positive -->
+<!--		<xsl:when test="starts-with($content,'&#x0223F;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0223F;')"/></xsl:call-template></xsl:when>		ac current -->
+		<xsl:when test="starts-with($content,'&#x02240;')"><xsl:value-of select="'\wr '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02240;')"/></xsl:call-template></xsl:when>		<!--/wr B: wreath product -->
+		<xsl:when test="starts-with($content,'&#x02241;')"><xsl:value-of select="'\nsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02241;')"/></xsl:call-template></xsl:when>		<!--/nsim N: not similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02242;')"><xsl:value-of select="'\eqsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02242;')"/></xsl:call-template></xsl:when>		<!--/esim R: equals, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02243;')"><xsl:value-of select="'\simeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02243;')"/></xsl:call-template></xsl:when>		<!--/simeq R: similar, equals -->
+		<xsl:when test="starts-with($content,'&#x02244;')"><xsl:value-of select="'\not\simeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02244;')"/></xsl:call-template></xsl:when>	<!--/nsimeq N: not similar, equals -->
+		<xsl:when test="starts-with($content,'&#x02245;')"><xsl:value-of select="'\cong '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02245;')"/></xsl:call-template></xsl:when>		<!--/cong R: congruent with -->
+<!--		<xsl:when test="starts-with($content,'&#x02246;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02246;')"/></xsl:call-template></xsl:when>		similar, not equals -->
+		<xsl:when test="starts-with($content,'&#x02247;')"><xsl:value-of select="'\ncong '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02247;')"/></xsl:call-template></xsl:when>		<!--/ncong N: not congruent with --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02248;')"><xsl:value-of select="'\approx '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02248;')"/></xsl:call-template></xsl:when>	<!--/approx R: approximate -->
+<!--		<xsl:when test="starts-with($content,'&#x02249;&#x00338;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02249;&#x00338;')"/></xsl:call-template></xsl:when>	not, vert, approximate -->
+		<xsl:when test="starts-with($content,'&#x02249;')"><xsl:value-of select="'\not\approx '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02249;')"/></xsl:call-template></xsl:when>	<!--/napprox N: not approximate -->
+		<xsl:when test="starts-with($content,'&#x0224A;')"><xsl:value-of select="'\approxeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224A;')"/></xsl:call-template></xsl:when>	<!--/approxeq R: approximate, equals --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x0224B;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224B;')"/></xsl:call-template></xsl:when>		approximately identical to -->
+<!--		<xsl:when test="starts-with($content,'&#x0224C;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224C;')"/></xsl:call-template></xsl:when>		/backcong R: reverse congruent -->
+		<xsl:when test="starts-with($content,'&#x0224D;')"><xsl:value-of select="'\asymp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224D;')"/></xsl:call-template></xsl:when>		<!--/asymp R: asymptotically equal to -->
+		<xsl:when test="starts-with($content,'&#x0224E;')"><xsl:value-of select="'\Bumpeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224E;')"/></xsl:call-template></xsl:when>	<!--/Bumpeq R: bumpy equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0224F;')"><xsl:value-of select="'\bumpeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0224F;')"/></xsl:call-template></xsl:when>	<!--/bumpeq R: bumpy equals, equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02250;')"><xsl:value-of select="'\doteq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02250;')"/></xsl:call-template></xsl:when>		<!--/doteq R: equals, single dot above -->
+		<xsl:when test="starts-with($content,'&#x02251;')"><xsl:value-of select="'\doteqdot '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02251;')"/></xsl:call-template></xsl:when>	<!--/doteqdot /Doteq R: eq, even dots --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02252;')"><xsl:value-of select="'\fallingdotseq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02252;')"/></xsl:call-template></xsl:when>	<!--/fallingdotseq R: eq, falling dots --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02253;')"><xsl:value-of select="'\risingdotseq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02253;')"/></xsl:call-template></xsl:when>	<!--/risingdotseq R: eq, rising dots --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x02254;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02254;')"/></xsl:call-template></xsl:when>		/coloneq R: colon, equals -->
+<!--		<xsl:when test="starts-with($content,'&#x02255;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02255;')"/></xsl:call-template></xsl:when>		/eqcolon R: equals, colon -->
+		<xsl:when test="starts-with($content,'&#x02256;')"><xsl:value-of select="'\eqcirc '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02256;')"/></xsl:call-template></xsl:when>	<!--/eqcirc R: circle on equals sign --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02257;')"><xsl:value-of select="'\circeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02257;')"/></xsl:call-template></xsl:when>	<!--/circeq R: circle, equals --> <!-- Required amssymb -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02258;')"><xsl:value-of select="'\stackrel{\frown}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02258;')"/></xsl:call-template></xsl:when>
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02259;')"><xsl:value-of select="'\stackrel{\wedge}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02259;')"/></xsl:call-template></xsl:when>	<!--/wedgeq R: corresponds to (wedge, equals) -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225A;')"><xsl:value-of select="'\stackrel{\vee}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225A;')"/></xsl:call-template></xsl:when>	<!--logical or, equals -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225B;')"><xsl:value-of select="'\stackrel{\star}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225B;')"/></xsl:call-template></xsl:when>	<!--equal, asterisk above -->
+		<xsl:when test="starts-with($content,'&#x0225C;')"><xsl:value-of select="'\triangleq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225C;')"/></xsl:call-template></xsl:when>	<!--/triangleq R: triangle, equals --> <!-- Required amssymb -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225D;')"><xsl:value-of select="'\stackrel{\scriptscriptstyle\mathrm{def}}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225D;')"/></xsl:call-template></xsl:when>
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225E;')"><xsl:value-of select="'\stackrel{\scriptscriptstyle\mathrm{m}}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225E;')"/></xsl:call-template></xsl:when>
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x0225F;')"><xsl:value-of select="'\stackrel{?}{=}'" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0225F;')"/></xsl:call-template></xsl:when>	<!--/questeq R: equal with questionmark -->
+<!--		<xsl:when test="starts-with($content,'&#x02260;&#x0FE00;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02260;&#x0FE00;')"/></xsl:call-template></xsl:when>	not equal, dot -->
+		<xsl:when test="starts-with($content,'&#x02260;')"><xsl:value-of select="'\ne '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02260;')"/></xsl:call-template></xsl:when>		<!--/ne /neq R: not equal -->
+<!--		<xsl:when test="starts-with($content,'&#x02261;&#x020E5;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02261;&#x020E5;')"/></xsl:call-template></xsl:when>	reverse not equivalent -->
+		<xsl:when test="starts-with($content,'&#x02261;')"><xsl:value-of select="'\equiv '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02261;')"/></xsl:call-template></xsl:when>		<!--/equiv R: identical with -->
+		<xsl:when test="starts-with($content,'&#x02262;')"><xsl:value-of select="'\not\equiv '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02262;')"/></xsl:call-template></xsl:when>	<!--/nequiv N: not identical with -->
+<!--		<xsl:when test="starts-with($content,'&#x02263;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02263;')"/></xsl:call-template></xsl:when>		-->
+		<xsl:when test="starts-with($content,'&#x02264;')"><xsl:value-of select="'\le '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02264;')"/></xsl:call-template></xsl:when>		<!--/leq /le R: less-than-or-equal -->
+		<xsl:when test="starts-with($content,'&#x02265;')"><xsl:value-of select="'\ge '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02265;')"/></xsl:call-template></xsl:when>		<!--/geq /ge R: greater-than-or-equal -->
+		<xsl:when test="starts-with($content,'&#x02266;')"><xsl:value-of select="'\leqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02266;')"/></xsl:call-template></xsl:when>		<!--/leqq R: less, double equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02267;')"><xsl:value-of select="'\geqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02267;')"/></xsl:call-template></xsl:when>		<!--/geqq R: greater, double equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02268;')"><xsl:value-of select="'\lneqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02268;')"/></xsl:call-template></xsl:when>		<!--/lneqq N: less, not double equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02269;')"><xsl:value-of select="'\gneqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02269;')"/></xsl:call-template></xsl:when>		<!--/gneqq N: greater, not dbl equals --> <!-- Required amssymb -->
+<!--		<xsl:when test="starts-with($content,'&#x0226A;&#x00338;&#x0FE00;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226A;&#x00338;&#x0FE00;')"/></xsl:call-template></xsl:when>	not much less than, variant -->
+<!--		<xsl:when test="starts-with($content,'&#x0226A;&#x00338;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226A;&#x00338;')"/></xsl:call-template></xsl:when>	not, vert, much less than -->
+		<xsl:when test="starts-with($content,'&#x0226A;')"><xsl:value-of select="'\ll '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226A;')"/></xsl:call-template></xsl:when>		<!--/ll R: double less-than sign -->
+<!--		<xsl:when test="starts-with($content,'&#x0226B;&#x00338;&#x0FE00;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226B;&#x00338;&#x0FE00;')"/></xsl:call-template></xsl:when>	not much greater than, variant -->
+<!--		<xsl:when test="starts-with($content,'&#x0226B;&#x00338;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226B;&#x00338;')"/></xsl:call-template></xsl:when>	not, vert, much greater than -->
+		<xsl:when test="starts-with($content,'&#x0226B;')"><xsl:value-of select="'\gg '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226B;')"/></xsl:call-template></xsl:when>		<!--/gg R: dbl greater-than sign -->
+		<xsl:when test="starts-with($content,'&#x0226C;')"><xsl:value-of select="'\between '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226C;')"/></xsl:call-template></xsl:when>	<!--/between R: between --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0226D;')"><xsl:value-of select="'\not\asymp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226D;')"/></xsl:call-template></xsl:when>
+		<xsl:when test="starts-with($content,'&#x0226E;')"><xsl:value-of select="'\nless '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226E;')"/></xsl:call-template></xsl:when>		<!--/nless N: not less-than --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0226F;')"><xsl:value-of select="'\ngtr '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0226F;')"/></xsl:call-template></xsl:when>		<!--/ngtr N: not greater-than --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02270;&#x020E5;')"><xsl:value-of select="'\nleq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02270;&#x020E5;')"/></xsl:call-template></xsl:when>	<!--/nleq N: not less-than-or-equal --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02270;')"><xsl:value-of select="'\nleqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02270;')"/></xsl:call-template></xsl:when>		<!--/nleqq N: not less, dbl equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02271;&#x020E5;')"><xsl:value-of select="'\ngeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02271;&#x020E5;')"/></xsl:call-template></xsl:when>	<!--/ngeq N: not greater-than-or-equal --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02271;')"><xsl:value-of select="'\ngeqq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02271;')"/></xsl:call-template></xsl:when>		<!--/ngeqq N: not greater, dbl equals --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02272;')"><xsl:value-of select="'\lesssim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02272;')"/></xsl:call-template></xsl:when>	<!--/lesssim R: less, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02273;')"><xsl:value-of select="'\gtrsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02273;')"/></xsl:call-template></xsl:when>	<!--/gtrsim R: greater, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02274;')"><xsl:value-of select="'\not\lesssim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02274;')"/></xsl:call-template></xsl:when>	<!--not less, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02275;')"><xsl:value-of select="'\not\gtrsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02275;')"/></xsl:call-template></xsl:when>	<!--not greater, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02276;')"><xsl:value-of select="'\lessgtr '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02276;')"/></xsl:call-template></xsl:when>	<!--/lessgtr R: less, greater --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02277;')"><xsl:value-of select="'\gtrless '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02277;')"/></xsl:call-template></xsl:when>	<!--/gtrless R: greater, less --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02278;')"><xsl:value-of select="'\not\lessgtr '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02278;')"/></xsl:call-template></xsl:when>	<!--not less, greater --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02279;')"><xsl:value-of select="'\not\gtrless '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02279;')"/></xsl:call-template></xsl:when>	<!--not greater, less --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0227A;')"><xsl:value-of select="'\prec '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227A;')"/></xsl:call-template></xsl:when>		<!--/prec R: precedes -->
+		<xsl:when test="starts-with($content,'&#x0227B;')"><xsl:value-of select="'\succ '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227B;')"/></xsl:call-template></xsl:when>		<!--/succ R: succeeds -->
+		<xsl:when test="starts-with($content,'&#x0227C;')"><xsl:value-of select="'\preccurlyeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227C;')"/></xsl:call-template></xsl:when>	<!--/preccurlyeq R: precedes, curly eq --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0227D;')"><xsl:value-of select="'\succcurlyeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227D;')"/></xsl:call-template></xsl:when>	<!--/succcurlyeq R: succeeds, curly eq --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0227E;')"><xsl:value-of select="'\precsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227E;')"/></xsl:call-template></xsl:when>	<!--/precsim R: precedes, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x0227F;')"><xsl:value-of select="'\succsim '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0227F;')"/></xsl:call-template></xsl:when>	<!--/succsim R: succeeds, similar --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02280;')"><xsl:value-of select="'\nprec '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02280;')"/></xsl:call-template></xsl:when>		<!--/nprec N: not precedes --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02281;')"><xsl:value-of select="'\nsucc '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02281;')"/></xsl:call-template></xsl:when>		<!--/nsucc N: not succeeds --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x02282;')"><xsl:value-of select="'\subset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02282;')"/></xsl:call-template></xsl:when>	<!--/subset R: subset or is implied by -->
+		<xsl:when test="starts-with($content,'&#x02283;')"><xsl:value-of select="'\supset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02283;')"/></xsl:call-template></xsl:when>	<!--/supset R: superset or implies -->
+		<xsl:when test="starts-with($content,'&#x02284;')"><xsl:value-of select="'\not\subset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02284;')"/></xsl:call-template></xsl:when>	<!--not subset -->
+		<xsl:when test="starts-with($content,'&#x02285;')"><xsl:value-of select="'\not\supset '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02285;')"/></xsl:call-template></xsl:when>	<!--not superset -->
+		<xsl:when test="starts-with($content,'&#x02286;')"><xsl:value-of select="'\subseteq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02286;')"/></xsl:call-template></xsl:when>	<!--/subseteq R: subset, equals -->
+		<xsl:when test="starts-with($content,'&#x02287;')"><xsl:value-of select="'\supseteq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02287;')"/></xsl:call-template></xsl:when>	<!--/supseteq R: superset, equals -->
+		<xsl:when test="starts-with($content,'&#x0228E;')"><xsl:value-of select="'\uplus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0228E;')"/></xsl:call-template></xsl:when>		<!--/uplus B: plus sign in union -->
+		<xsl:when test="starts-with($content,'&#x02293;')"><xsl:value-of select="'\sqcap '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02293;')"/></xsl:call-template></xsl:when>		<!--/sqcap B: square intersection -->
+		<xsl:when test="starts-with($content,'&#x02294;')"><xsl:value-of select="'\bigsqcup '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02294;')"/></xsl:call-template></xsl:when>		<!--/sqcup B: square union -->
+		<xsl:when test="starts-with($content,'&#x02295;')"><xsl:value-of select="'\oplus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02295;')"/></xsl:call-template></xsl:when>		<!--/oplus B: plus sign in circle -->
+		<xsl:when test="starts-with($content,'&#x02296;')"><xsl:value-of select="'\ominus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02296;')"/></xsl:call-template></xsl:when>	<!--/ominus B: minus sign in circle -->
+		<xsl:when test="starts-with($content,'&#x02297;')"><xsl:value-of select="'\otimes '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02297;')"/></xsl:call-template></xsl:when>	<!--/otimes B: multiply sign in circle -->
+		<xsl:when test="starts-with($content,'&#x02298;')"><xsl:value-of select="'\oslash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02298;')"/></xsl:call-template></xsl:when>	<!--/oslash B: solidus in circle -->
+<!-- ? -->	<xsl:when test="starts-with($content,'&#x02299;')"><xsl:value-of select="'\odot '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x02299;')"/></xsl:call-template></xsl:when>		<!--/odot B: middle dot in circle --> <!--/bigodot L: circle dot operator -->
+		<xsl:when test="starts-with($content,'&#x0229F;')"><xsl:value-of select="'\boxminus '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x0229F;')"/></xsl:call-template></xsl:when>	<!--/boxminus B: minus sign in box --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022A4;')"><xsl:value-of select="'\top '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A4;')"/></xsl:call-template></xsl:when>		<!--/top top -->
+		<xsl:when test="starts-with($content,'&#x022A5;')"><xsl:value-of select="'\perp '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A5;')"/></xsl:call-template></xsl:when>		<!--/perp R: perpendicular --><!--/bot bottom -->
+		<xsl:when test="starts-with($content,'&#x022A6;')"><xsl:value-of select="'\vdash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A6;')"/></xsl:call-template></xsl:when>		<!--/vdash R: vertical, dash -->
+		<xsl:when test="starts-with($content,'&#x022A7;')"><xsl:value-of select="'\vDash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A7;')"/></xsl:call-template></xsl:when>		<!--/vDash R: vertical, dbl dash --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022A8;')"><xsl:value-of select="'\models '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022A8;')"/></xsl:call-template></xsl:when>	<!--/models R: -->
+		<xsl:when test="starts-with($content,'&#x022AA;')"><xsl:value-of select="'\Vvdash '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022AA;')"/></xsl:call-template></xsl:when>	<!--/Vvdash R: triple vertical, dash --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022C0;')"><xsl:value-of select="'\bigwedge '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C0;')"/></xsl:call-template></xsl:when>	<!--/bigwedge L: logical or operator -->
+		<xsl:when test="starts-with($content,'&#x022C1;')"><xsl:value-of select="'\bigvee '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C1;')"/></xsl:call-template></xsl:when>	<!--/bigcap L: intersection operator -->
+		<xsl:when test="starts-with($content,'&#x022C2;')"><xsl:value-of select="'\bigcap '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C2;')"/></xsl:call-template></xsl:when>	<!--/bigvee L: logical and operator -->
+		<xsl:when test="starts-with($content,'&#x022C3;')"><xsl:value-of select="'\bigcup '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C3;')"/></xsl:call-template></xsl:when>	<!--/bigcup L: union operator -->
+		<xsl:when test="starts-with($content,'&#x022C4;')"><xsl:value-of select="'\diamond '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C4;')"/></xsl:call-template></xsl:when>	<!--/diamond B: open diamond -->
+		<xsl:when test="starts-with($content,'&#x022C5;')"><xsl:value-of select="'\cdot '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C5;')"/></xsl:call-template></xsl:when>		<!--/cdot B: small middle dot -->
+		<xsl:when test="starts-with($content,'&#x022C6;')"><xsl:value-of select="'\star '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C6;')"/></xsl:call-template></xsl:when>		<!--/star B: small star, filled -->
+		<xsl:when test="starts-with($content,'&#x022C7;')"><xsl:value-of select="'\divideontimes '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C7;')"/></xsl:call-template></xsl:when>	<!--/divideontimes B: division on times --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022C8;')"><xsl:value-of select="'\bowtie '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022C8;')"/></xsl:call-template></xsl:when>	<!--/bowtie R: -->
+		<xsl:when test="starts-with($content,'&#x022CD;')"><xsl:value-of select="'\backsimeq '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022CD;')"/></xsl:call-template></xsl:when>	<!--/backsimeq R: reverse similar, eq --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x022EF;')"><xsl:value-of select="'\cdots '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022EF;')"/></xsl:call-template></xsl:when>		<!--/cdots, three dots, centered -->
+<!--		<xsl:when test="starts-with($content,'&#x022F0;')"><xsl:value-of select="' '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022F0;')"/></xsl:call-template></xsl:when>		three dots, ascending -->
+		<xsl:when test="starts-with($content,'&#x022F1;')"><xsl:value-of select="'\ddots '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x022F1;')"/></xsl:call-template></xsl:when>		<!--/ddots, three dots, descending -->
+<!-- ====================================================================== -->
+		<xsl:when test="starts-with($content,'&#x025A1;')"><xsl:value-of select="'\square '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x025A1;')"/></xsl:call-template></xsl:when>	<!--/square, square --> <!-- Required amssymb -->
+		<xsl:when test="starts-with($content,'&#x025AA;')"><xsl:value-of select="'\blacksquare '" /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '&#x025AA;')"/></xsl:call-template></xsl:when>	<!--/blacksquare, square, filled  --> <!-- Required amssymb -->
+		<xsl:when test='starts-with($content,"&apos;")'><xsl:value-of select='"\text{&apos;}"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select='substring-after($content, "&apos;")'/></xsl:call-template></xsl:when><!-- \text required amslatex -->
+		<xsl:when test='starts-with($content,"(")'><xsl:value-of select='"\left("' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '(')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,")")'><xsl:value-of select='"\right)"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, ')')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,"[")'><xsl:value-of select='"\left["' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '[')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,"]")'><xsl:value-of select='"\right]"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, ']')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,"{")'><xsl:value-of select='"\left\{"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '{')"/></xsl:call-template></xsl:when>
+		<xsl:when test='starts-with($content,"}")'><xsl:value-of select='"\right\}"' /><xsl:call-template name="replaceEntities"><xsl:with-param name="content" select="substring-after($content, '}')"/></xsl:call-template></xsl:when>
+		<xsl:otherwise>
+			<xsl:value-of select="substring($content,1,1)"/>
+			<xsl:call-template name="replaceEntities">
+				<xsl:with-param name="content" select="substring($content, 2)"/>
+			</xsl:call-template>
+		</xsl:otherwise>
+	</xsl:choose></xsl:if>
+</xsl:template>
+<xsl:template name="replaceMtextEntities">
+	<xsl:param name="content"/>
+	<xsl:choose>
+	<xsl:when test="contains($content,'&#x02009;&#x0200A;&#x0200A;')">	<!-- ThickSpace - space of width 5/18 em -->
+		<xsl:call-template name="replaceMtextEntities">
+			<xsl:with-param name="content" select="concat(substring-before($content,'&#x02009;&#x0200A;&#x0200A;'),'\hspace{0.28em}',substring-after($content,'&#x02009;&#x0200A;&#x0200A;'))"/>
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:when test="contains($content,'&#x02009;')">	<!-- ThinSpace - space of width 3/18 em -->
+		<xsl:call-template name="replaceMtextEntities">
+			<xsl:with-param name="content" select="concat(substring-before($content,'&#x02009;'),'\hspace{0.17em}',substring-after($content,'&#x02009;'))"/>
+		</xsl:call-template>
+	</xsl:when>
+	<xsl:otherwise>
+		<xsl:value-of select="normalize-space($content)"/>
+	</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+</xsl:stylesheet>

ultradata_math_parser/mmltex/glayout.xsl ADDED Viewed

	@@ -0,0 +1,220 @@

+<?xml version='1.0' encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+		xmlns:m="http://www.w3.org/1998/Math/MathML"
+                version='1.0'>
+<!-- ====================================================================== -->
+<!-- $id: glayout.xsl, 2002/17/05 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+<xsl:template match="m:mfrac">
+	<xsl:choose>
+		<xsl:when test="@bevelled='true'">
+<!--			<xsl:text>\raisebox{1ex}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}\!\left/ \!\raisebox{-1ex}{</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}\right.</xsl:text>-->
+		</xsl:when>
+		<xsl:when test="@linethickness">
+			<xsl:text>\genfrac{}{}{</xsl:text>
+			<xsl:choose>
+				<xsl:when test="number(@linethickness)">
+					<xsl:value-of select="@linethickness div 10"/>
+					<xsl:text>ex</xsl:text>
+				</xsl:when>
+				<xsl:when test="@linethickness='thin'">
+					<xsl:text>.05ex</xsl:text>
+				</xsl:when>
+				<xsl:when test="@linethickness='medium'"/>
+				<xsl:when test="@linethickness='thick'">
+					<xsl:text>.2ex</xsl:text>
+				</xsl:when>
+				<xsl:otherwise>
+					<xsl:value-of select="@linethickness"/>
+				</xsl:otherwise>
+			</xsl:choose>
+			<xsl:text>}{}{</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\frac{</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:if test="@numalign='right'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:if test="@numalign='left'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:text>}{</xsl:text>
+	<xsl:if test="@denomalign='right'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:apply-templates select="./*[2]"/>
+		<xsl:if test="@denomalign='left'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:mroot">
+	<xsl:choose>
+		<xsl:when test="count(./*)=2">
+			<xsl:text>\sqrt[</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>]{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+		<!-- number of argumnets is not 2 - code 25 -->
+			<xsl:message>exception 25:</xsl:message>
+			<xsl:text>\text{exception 25:}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template match="m:msqrt">
+	<xsl:text>\sqrt{</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:mfenced">
+	<xsl:choose>
+		<xsl:when test="@open">
+			<xsl:if test="translate(@open,'{}[]()|','{{{{{{{')='{'">
+				<xsl:text>\left</xsl:text>
+			</xsl:if>
+			<xsl:if test="@open='{' or @open='}'">
+				<xsl:text>\</xsl:text>
+			</xsl:if>
+			<xsl:value-of select="@open"/>
+		</xsl:when>
+		<xsl:otherwise><xsl:text>\left(</xsl:text></xsl:otherwise>
+	</xsl:choose>
+	<xsl:choose>
+		<xsl:when test="count(./*)>1">
+			<xsl:variable name="symbol">
+				<xsl:choose>
+					<xsl:when test="@separators">
+						<xsl:call-template name="startspace">
+							<xsl:with-param name="symbol" select="@separators"/>
+						</xsl:call-template>
+					</xsl:when>
+					<xsl:otherwise>,</xsl:otherwise>
+				</xsl:choose>
+			</xsl:variable>
+			<xsl:for-each select="./*">
+				<xsl:apply-templates select="."/>
+				<xsl:if test="not(position()=last())">
+					<xsl:choose>
+						<xsl:when test="position()>string-length($symbol)">
+							<xsl:value-of select="substring($symbol,string-length($symbol))"/>
+						</xsl:when>
+						<xsl:otherwise>
+							<xsl:value-of select="substring($symbol,position(),1)"/>
+						</xsl:otherwise>
+					</xsl:choose>
+				</xsl:if>
+			</xsl:for-each>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:apply-templates/>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:choose>
+		<xsl:when test="@close">
+			<xsl:if test="translate(@open,'{}[]()|','{{{{{{{')='{'">
+				<xsl:text>\right</xsl:text>
+			</xsl:if>
+			<xsl:if test="@open='{' or @open='}'">
+				<xsl:text>\</xsl:text>
+			</xsl:if>
+			<xsl:value-of select="@close"/>
+		</xsl:when>
+		<xsl:otherwise><xsl:text>\right)</xsl:text></xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template match="m:mphantom">
+	<xsl:text>\phantom{</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:menclose">
+	<xsl:choose>
+		<xsl:when test="@notation = 'actuarial'">
+			<xsl:text>\overline{</xsl:text>
+			<xsl:apply-templates/>
+			<xsl:text>\hspace{.2em}|}</xsl:text>
+		</xsl:when>
+		<xsl:when test="@notation = 'radical'">
+			<xsl:text>\sqrt{</xsl:text>
+			<xsl:apply-templates/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\overline{)</xsl:text>
+			<xsl:apply-templates/>
+			<xsl:text>}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template match="m:mrow">
+	<xsl:apply-templates/>
+</xsl:template>
+<xsl:template match="m:mstyle">
+	<xsl:if test="@background">
+		<xsl:text>\colorbox[rgb]{</xsl:text>
+		<xsl:call-template name="color">
+			<xsl:with-param name="color" select="@background"/>
+		</xsl:call-template>
+		<xsl:text>}{$</xsl:text>
+	</xsl:if>
+	<xsl:if test="@color">
+		<xsl:text>\textcolor[rgb]{</xsl:text>
+		<xsl:call-template name="color">
+			<xsl:with-param name="color" select="@color"/>
+		</xsl:call-template>
+		<xsl:text>}{</xsl:text>
+	</xsl:if>
+	<xsl:apply-templates/>
+	<xsl:if test="@color">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="@background">
+		<xsl:text>$}</xsl:text>
+	</xsl:if>
+</xsl:template>
+<!--
+<xsl:template match="m:mstyle">
+	<xsl:if test="@displaystyle='true'">
+		<xsl:text>{\displaystyle</xsl:text>
+	</xsl:if>
+	<xsl:if test="@scriptlevel=2">
+		<xsl:text>{\scriptscriptstyle</xsl:text>
+	</xsl:if>
+	<xsl:apply-templates/>
+	<xsl:if test="@scriptlevel=2">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="@displaystyle='true'">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+</xsl:template>
+-->
+<xsl:template match="m:merror">
+	<xsl:apply-templates/>
+</xsl:template>
+</xsl:stylesheet>

ultradata_math_parser/mmltex/mmltex.xsl ADDED Viewed

	@@ -0,0 +1,45 @@

+<?xml version='1.0' encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+		xmlns:m="http://www.w3.org/1998/Math/MathML"
+                version='1.0'>
+<xsl:output method="text" indent="no" encoding="UTF-8"/>
+<!-- ====================================================================== -->
+<!-- $id: mmltex.xsl, 2002/22/11 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+<xsl:include href="tokens.xsl"/>
+<xsl:include href="glayout.xsl"/>
+<xsl:include href="scripts.xsl"/>
+<xsl:include href="tables.xsl"/>
+<xsl:include href="entities.xsl"/>
+<xsl:include href="cmarkup.xsl"/>
+<!-- Note: variables colora (template color) and symbola (template startspace) only for Sablotron -->
+<xsl:template name="startspace">
+	<xsl:param name="symbol"/>
+	<xsl:if test="contains($symbol,' ')">
+		<xsl:variable name="symbola" select="concat(substring-before($symbol,' '),substring-after($symbol,' '))"/>
+		<xsl:call-template name="startspace">
+			<xsl:with-param name="symbol" select="$symbola"/>
+		</xsl:call-template>
+	</xsl:if>
+	<xsl:if test="not(contains($symbol,' '))">
+		<xsl:value-of select="$symbol"/>
+	</xsl:if>
+</xsl:template>
+<xsl:strip-space elements="m:*"/>
+<xsl:template match="m:math">
+	<xsl:text>&#x00024;</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>&#x00024;</xsl:text>
+</xsl:template>
+</xsl:stylesheet>

ultradata_math_parser/mmltex/scripts.xsl ADDED Viewed

	@@ -0,0 +1,292 @@

+<?xml version='1.0' encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+		xmlns:m="http://www.w3.org/1998/Math/MathML"
+                version='1.0'>
+<!-- ====================================================================== -->
+<!-- $Id: scripts.xsl,v 1.1.1.1 2002/10/26 14:20:06 shade33 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+<xsl:template match="m:munderover">
+	<xsl:variable name="base">
+		<xsl:call-template name="startspace">
+			<xsl:with-param name="symbol" select="./*[1]"/>
+		</xsl:call-template>
+	</xsl:variable>
+	<xsl:variable name="under">
+		<xsl:call-template name="startspace">
+			<xsl:with-param name="symbol" select="./*[2]"/>
+		</xsl:call-template>
+	</xsl:variable>
+	<xsl:variable name="over">
+		<xsl:call-template name="startspace">
+			<xsl:with-param name="symbol" select="./*[3]"/>
+		</xsl:call-template>
+	</xsl:variable>
+	<xsl:choose>
+		<xsl:when test="$over='&#x000AF;'">	<!-- OverBar - over bar -->
+			<xsl:text>\overline{</xsl:text>
+			<xsl:call-template name="munder">
+				<xsl:with-param name="base" select="$base"/>
+				<xsl:with-param name="under" select="$under"/>
+			</xsl:call-template>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$over='&#x0FE37;'">	<!-- OverBrace - over brace -->
+			<xsl:text>\overbrace{</xsl:text>
+			<xsl:call-template name="munder">
+				<xsl:with-param name="base" select="$base"/>
+				<xsl:with-param name="under" select="$under"/>
+			</xsl:call-template>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$under='&#x00332;'">	<!-- UnderBar - combining low line -->
+			<xsl:text>\underline{</xsl:text>
+			<xsl:call-template name="mover">
+				<xsl:with-param name="base" select="$base"/>
+				<xsl:with-param name="over" select="$over"/>
+				<xsl:with-param name="pos_over" select="3"/>
+			</xsl:call-template>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$under='&#x0FE38;'">	<!-- UnderBrace - under brace -->
+			<xsl:text>\underbrace{</xsl:text>
+			<xsl:call-template name="mover">
+				<xsl:with-param name="base" select="$base"/>
+				<xsl:with-param name="over" select="$over"/>
+				<xsl:with-param name="pos_over" select="3"/>
+			</xsl:call-template>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="translate($base,'&#x0220F;&#x02210;&#x022c2;&#x022c3;&#x02294;',
+						'&#x02211;&#x02211;&#x02211;&#x02211;&#x02211;')='&#x02211;'">
+<!-- if $base is operator, such as
+			&#x02211;	/sum L: summation operator
+			&#x0220F;	/prod L: product operator
+			&#x02210;	/coprod L: coproduct operator
+			&#x022c2;	/bigcap
+			&#x022c3;	/bigcup
+			&#x02294;	/bigsqcup
+-->
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>_{</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}^{</xsl:text>
+			<xsl:apply-templates select="./*[3]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\underset{</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}{\overset{</xsl:text>
+			<xsl:apply-templates select="./*[3]"/>
+			<xsl:text>}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template match="m:mover">
+	<xsl:call-template name="mover">
+		<xsl:with-param name="base">
+			<xsl:call-template name="startspace">
+				<xsl:with-param name="symbol" select="./*[1]"/>
+			</xsl:call-template>
+		</xsl:with-param>
+		<xsl:with-param name="over">
+			<xsl:call-template name="startspace">
+				<xsl:with-param name="symbol" select="./*[2]"/>
+			</xsl:call-template>
+		</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<xsl:template match="m:munder">
+	<xsl:call-template name="munder">
+		<xsl:with-param name="base">
+			<xsl:call-template name="startspace">
+				<xsl:with-param name="symbol" select="./*[1]"/>
+			</xsl:call-template>
+		</xsl:with-param>
+		<xsl:with-param name="under">
+			<xsl:call-template name="startspace">
+				<xsl:with-param name="symbol" select="./*[2]"/>
+			</xsl:call-template>
+		</xsl:with-param>
+	</xsl:call-template>
+</xsl:template>
+<xsl:template name="mover">
+	<xsl:param name="base"/>
+	<xsl:param name="over"/>
+	<xsl:param name="pos_over" select="2"/>
+	<xsl:choose>
+		<xsl:when test="$over='&#x000AF;'">	<!-- OverBar - over bar -->
+			<xsl:text>\overline{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$over='&#x0FE37;'">	<!-- OverBrace - over brace -->
+			<xsl:text>\overbrace{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="translate($base,'&#x0220F;&#x02210;&#x022c2;&#x022c3;&#x02294;',
+						'&#x02211;&#x02211;&#x02211;&#x02211;&#x02211;')='&#x02211;'">
+<!-- if $base is operator, such as
+			&#x02211;	/sum L: summation operator
+			&#x0220F;	/prod L: product operator
+			&#x02210;	/coprod L: coproduct operator
+			&#x022c2;	/bigcap
+			&#x022c3;	/bigcup
+			&#x02294;	/bigsqcup
+-->
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>^{</xsl:text>
+			<xsl:apply-templates select="./*[$pos_over]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\stackrel{</xsl:text>
+			<xsl:apply-templates select="./*[$pos_over]"/>
+			<xsl:text>}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+			<!--
+			<xsl:text>\overset{</xsl:text>
+			<xsl:apply-templates select="./*[$pos_over]"/>
+			<xsl:text>}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>-->
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template name="munder">
+	<xsl:param name="base"/>
+	<xsl:param name="under"/>
+	<xsl:choose>
+		<xsl:when test="$under='&#x00332;'">	<!-- UnderBar - combining low line -->
+			<xsl:text>\underline{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="$under='&#x0FE38;'">	<!-- UnderBrace - under brace -->
+			<xsl:text>\underbrace{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:when test="translate($base,'&#x0220F;&#x02210;&#x022c2;&#x022c3;&#x02294;',
+						'&#x02211;&#x02211;&#x02211;&#x02211;&#x02211;')='&#x02211;'">
+<!-- if $base is operator, such as
+			&#x02211;	/sum L: summation operator
+			&#x0220F;	/prod L: product operator
+			&#x02210;	/coprod L: coproduct operator
+			&#x022c2;	/bigcap
+			&#x022c3;	/bigcup
+			&#x02294;	/bigsqcup
+-->
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>_{</xsl:text>
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:text>\underset{</xsl:text>		<!-- Required AmsMath package -->
+			<xsl:apply-templates select="./*[2]"/>
+			<xsl:text>}{</xsl:text>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:text>}</xsl:text>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template match="m:msubsup">
+	<xsl:text>{</xsl:text>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:text>}_{</xsl:text>
+	<xsl:apply-templates select="./*[2]"/>
+	<xsl:text>}^{</xsl:text>
+	<xsl:apply-templates select="./*[3]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:msup">
+	<xsl:text>{</xsl:text>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:text>}^{</xsl:text>
+	<xsl:apply-templates select="./*[2]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:msub">
+	<xsl:text>{</xsl:text>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:text>}_{</xsl:text>
+	<xsl:apply-templates select="./*[2]"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:mmultiscripts" mode="mprescripts">
+	<xsl:for-each select="m:mprescripts/following-sibling::*">
+		<xsl:if test="position() mod 2 and local-name(.)!='none'">
+			<xsl:text>{}_{</xsl:text>
+			<xsl:apply-templates select="."/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+		<xsl:if test="not(position() mod 2) and local-name(.)!='none'">
+			<xsl:text>{}^{</xsl:text>
+			<xsl:apply-templates select="."/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+	</xsl:for-each>
+	<xsl:apply-templates select="./*[1]"/>
+	<xsl:for-each select="m:mprescripts/preceding-sibling::*[position()!=last()]">
+		<xsl:if test="position()>2 and local-name(.)!='none'">
+			<xsl:text>{}</xsl:text>
+		</xsl:if>
+		<xsl:if test="position() mod 2 and local-name(.)!='none'">
+			<xsl:text>_{</xsl:text>
+			<xsl:apply-templates select="."/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+		<xsl:if test="not(position() mod 2) and local-name(.)!='none'">
+			<xsl:text>^{</xsl:text>
+			<xsl:apply-templates select="."/>
+			<xsl:text>}</xsl:text>
+		</xsl:if>
+	</xsl:for-each>
+</xsl:template>
+<xsl:template match="m:mmultiscripts">
+	<xsl:choose>
+		<xsl:when test="m:mprescripts">
+			<xsl:apply-templates select="." mode="mprescripts"/>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:apply-templates select="./*[1]"/>
+			<xsl:for-each select="*[position()>1]">
+				<xsl:if test="position()>2 and local-name(.)!='none'">
+					<xsl:text>{}</xsl:text>
+				</xsl:if>
+				<xsl:if test="position() mod 2 and local-name(.)!='none'">
+					<xsl:text>_{</xsl:text>
+					<xsl:apply-templates select="."/>
+					<xsl:text>}</xsl:text>
+				</xsl:if>
+				<xsl:if test="not(position() mod 2) and local-name(.)!='none'">
+					<xsl:text>^{</xsl:text>
+					<xsl:apply-templates select="."/>
+					<xsl:text>}</xsl:text>
+				</xsl:if>
+			</xsl:for-each>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+</xsl:stylesheet>

ultradata_math_parser/mmltex/tables.xsl ADDED Viewed

	@@ -0,0 +1,130 @@

+<?xml version='1.0' encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+		xmlns:m="http://www.w3.org/1998/Math/MathML"
+                version='1.0'>
+<!-- ====================================================================== -->
+<!-- $id: tables.xsl, 2002/17/05 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+<xsl:template match="m:mtd[@columnspan]">
+	<xsl:text>\multicolumn{</xsl:text>
+	<xsl:value-of select="@columnspan"/>
+	<xsl:text>}{c}{</xsl:text>
+	<xsl:apply-templates/>
+	<xsl:text>}</xsl:text>
+	<xsl:if test="count(following-sibling::*)>0">
+		<xsl:text>&amp; </xsl:text>
+	</xsl:if>
+</xsl:template>
+<xsl:template match="m:mtd">
+	<xsl:if test="@columnalign='right' or @columnalign='center'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:apply-templates/>
+	<xsl:if test="@columnalign='left' or @columnalign='center'">
+		<xsl:text>\hfill </xsl:text>
+	</xsl:if>
+	<xsl:if test="count(following-sibling::*)>0">
+<!--    this test valid for Sablotron, another form - test="not(position()=last())".
+	Also for m:mtd[@columnspan] and m:mtr  -->
+		<xsl:text>&amp; </xsl:text>
+	</xsl:if>
+</xsl:template>
+<xsl:template match="m:mtr">
+	<xsl:apply-templates/>
+	<xsl:if test="count(following-sibling::*)>0">
+		<xsl:text>\\ </xsl:text>
+	</xsl:if>
+</xsl:template>
+<xsl:template match="m:mtable">
+	<xsl:text>\begin{array}{</xsl:text>
+	<xsl:if test="@frame='solid'">
+		<xsl:text>|</xsl:text>
+	</xsl:if>
+	<xsl:variable name="numbercols" select="count(./m:mtr[1]/m:mtd[not(@columnspan)])+sum(./m:mtr[1]/m:mtd/@columnspan)"/>
+	<xsl:choose>
+		<xsl:when test="@columnalign">
+			<xsl:variable name="colalign">
+				<xsl:call-template name="colalign">
+					<xsl:with-param name="colalign" select="@columnalign"/>
+				</xsl:call-template>
+			</xsl:variable>
+			<xsl:choose>
+				<xsl:when test="string-length($colalign) > $numbercols">
+					<xsl:value-of select="substring($colalign,1,$numbercols)"/>
+				</xsl:when>
+				<xsl:when test="string-length($colalign) &lt; $numbercols">
+					<xsl:value-of select="$colalign"/>
+					<xsl:call-template name="generate-string">
+						<xsl:with-param name="text" select="substring($colalign,string-length($colalign))"/>
+						<xsl:with-param name="count" select="$numbercols - string-length($colalign)"/>
+					</xsl:call-template>
+				</xsl:when>
+				<xsl:otherwise>
+					<xsl:value-of select="$colalign"/>
+				</xsl:otherwise>
+			</xsl:choose>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:call-template name="generate-string">
+				<xsl:with-param name="text" select="'c'"/>
+				<xsl:with-param name="count" select="$numbercols"/>
+			</xsl:call-template>
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:if test="@frame='solid'">
+		<xsl:text>|</xsl:text>
+	</xsl:if>
+	<xsl:text>}</xsl:text>
+	<xsl:if test="@frame='solid'">
+		<xsl:text>\hline </xsl:text>
+	</xsl:if>
+	<xsl:apply-templates/>
+	<xsl:if test="@frame='solid'">
+		<xsl:text>\\ \hline</xsl:text>
+	</xsl:if>
+	<xsl:text>\end{array}</xsl:text>
+</xsl:template>
+<xsl:template name="colalign">
+	<xsl:param name="colalign"/>
+	<xsl:choose>
+		<xsl:when test="contains($colalign,' ')">
+			<xsl:value-of select="substring($colalign,1,1)"/>
+			<xsl:call-template name="colalign">
+				<xsl:with-param name="colalign" select="substring-after($colalign,' ')"/>
+			</xsl:call-template>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:value-of select="substring($colalign,1,1)"/>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template name="generate-string">
+<!-- template from XSLT Standard Library v1.1 -->
+    <xsl:param name="text"/>
+    <xsl:param name="count"/>
+    <xsl:choose>
+      <xsl:when test="string-length($text) = 0 or $count &lt;= 0"/>
+      <xsl:otherwise>
+	<xsl:value-of select="$text"/>
+	<xsl:call-template name="generate-string">
+	  <xsl:with-param name="text" select="$text"/>
+	  <xsl:with-param name="count" select="$count - 1"/>
+	</xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
+</xsl:template>
+</xsl:stylesheet>

ultradata_math_parser/mmltex/tokens.xsl ADDED Viewed

	@@ -0,0 +1,296 @@

+<?xml version='1.0' encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+		xmlns:m="http://www.w3.org/1998/Math/MathML"
+                version='1.0'>
+<!-- ====================================================================== -->
+<!-- $id: tokens.xsl, 2002/22/11 Exp $
+     This file is part of the XSLT MathML Library distribution.
+     See ./README or http://www.raleigh.ru/MathML/mmltex for
+     copyright and other information                                        -->
+<!-- ====================================================================== -->
+<xsl:template match="m:mi|m:mn|m:mo|m:mtext|m:ms">
+	<xsl:call-template name="CommonTokenAtr"/>
+</xsl:template>
+<xsl:template name="mi">
+	<xsl:choose>
+		<xsl:when test="string-length(normalize-space(.))>1 and not(@mathvariant)">
+			<xsl:text>\mathrm{</xsl:text>
+				<xsl:apply-templates/>
+			<xsl:text>}</xsl:text>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:apply-templates/>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template name="mn">
+	<xsl:apply-templates/>
+</xsl:template>
+<xsl:template name="mo">
+	<xsl:apply-templates/>
+</xsl:template>
+<xsl:template name="mtext">
+	<xsl:variable name="content">
+		<xsl:call-template name="replaceMtextEntities">
+			<xsl:with-param name="content" select="."/>
+		</xsl:call-template>
+	</xsl:variable>
+	<xsl:text>\text{</xsl:text>
+	<xsl:value-of select="$content"/>
+	<xsl:text>}</xsl:text>
+</xsl:template>
+<xsl:template match="m:mspace">
+	<xsl:text>\phantom{\rule</xsl:text>
+	<xsl:if test="@depth">
+		<xsl:text>[-</xsl:text>
+		<xsl:value-of select="@depth"/>
+		<xsl:text>]</xsl:text>
+	</xsl:if>
+	<xsl:text>{</xsl:text>
+	<xsl:if test="not(@width)">
+		<xsl:text>0ex</xsl:text>
+	</xsl:if>
+	<xsl:value-of select="@width"/>
+	<xsl:text>}{</xsl:text>
+	<xsl:if test="not(@height)">
+		<xsl:text>0ex</xsl:text>
+	</xsl:if>
+	<xsl:value-of select="@height"/>
+	<xsl:text>}}</xsl:text>
+</xsl:template>
+<xsl:template name="ms">
+	<xsl:choose>
+		<xsl:when test="@lquote"><xsl:value-of select="@lquote"/></xsl:when>
+		<xsl:otherwise><xsl:text>"</xsl:text></xsl:otherwise>
+	</xsl:choose><xsl:apply-templates/><xsl:choose>
+		<xsl:when test="@rquote"><xsl:value-of select="@rquote"/></xsl:when>
+		<xsl:otherwise><xsl:text>"</xsl:text></xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template name="CommonTokenAtr">
+	<xsl:if test="@mathbackground">
+		<xsl:text>\colorbox[rgb]{</xsl:text>
+		<xsl:call-template name="color">
+			<xsl:with-param name="color" select="@mathbackground"/>
+		</xsl:call-template>
+		<xsl:text>}{$</xsl:text>
+	</xsl:if>
+	<xsl:if test="@color or @mathcolor"> <!-- Note: @color is deprecated in MathML 2.0 -->
+		<xsl:text>\textcolor[rgb]{</xsl:text>
+		<xsl:call-template name="color">
+			<xsl:with-param name="color" select="@color|@mathcolor"/>
+		</xsl:call-template>
+		<xsl:text>}{</xsl:text>
+	</xsl:if>
+	<xsl:if test="@mathvariant">
+		<xsl:choose>
+			<xsl:when test="@mathvariant='normal'">
+				<xsl:text>\mathrm{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold'">
+				<xsl:text>\mathbf{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='italic'">
+				<xsl:text>\mathit{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold-italic'">	<!-- Required definition -->
+				<xsl:text>\mathbit{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='double-struck'">	<!-- Required amsfonts -->
+				<xsl:text>\mathbb{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold-fraktur'">	<!-- Error -->
+				<xsl:text>{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='script'">
+				<xsl:text>\mathcal{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold-script'">	<!-- Error -->
+				<xsl:text>\mathsc{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='fraktur'">	<!-- Required amsfonts -->
+				<xsl:text>\mathfrak{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='sans-serif'">
+				<xsl:text>\mathsf{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='bold-sans-serif'"> <!-- Required definition -->
+				<xsl:text>\mathbsf{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='sans-serif-italic'"> <!-- Required definition -->
+				<xsl:text>\mathsfit{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='sans-serif-bold-italic'">	<!-- Error -->
+				<xsl:text>\mathbsfit{</xsl:text>
+			</xsl:when>
+			<xsl:when test="@mathvariant='monospace'">
+				<xsl:text>\mathtt{</xsl:text>
+			</xsl:when>
+			<xsl:otherwise>
+				<xsl:text>{</xsl:text>
+			</xsl:otherwise>
+		</xsl:choose>
+	</xsl:if>
+	<xsl:call-template name="selectTemplate"/>
+	<xsl:if test="@mathvariant">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="@color or @mathcolor">
+		<xsl:text>}</xsl:text>
+	</xsl:if>
+	<xsl:if test="@mathbackground">
+		<xsl:text>$}</xsl:text>
+	</xsl:if>
+</xsl:template>
+<xsl:template name="selectTemplate">
+<!--	<xsl:variable name="name" select="local-name()"/>
+	<xsl:call-template name="{$name}"/>-->
+	<xsl:choose>
+		<xsl:when test="local-name(.)='mi'">
+			<xsl:call-template name="mi"/>
+		</xsl:when>
+		<xsl:when test="local-name(.)='mn'">
+			<xsl:call-template name="mn"/>
+		</xsl:when>
+		<xsl:when test="local-name(.)='mo'">
+			<xsl:call-template name="mo"/>
+		</xsl:when>
+		<xsl:when test="local-name(.)='mtext'">
+			<xsl:call-template name="mtext"/>
+		</xsl:when>
+		<xsl:when test="local-name(.)='ms'">
+			<xsl:call-template name="ms"/>
+		</xsl:when>
+	</xsl:choose>
+</xsl:template>
+<xsl:template name="color">
+<!-- NB: Variables colora and valueColor{n} only for Sablotron -->
+	<xsl:param name="color"/>
+	<xsl:variable name="colora" select="translate($color,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')"/>
+	<xsl:choose>
+	<xsl:when test="starts-with($colora,'#') and string-length($colora)=4">
+		<xsl:variable name="valueColor">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,2,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="$valueColor div 15"/><xsl:text>,</xsl:text>
+		<xsl:variable name="valueColor1">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,3,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="$valueColor1 div 15"/><xsl:text>,</xsl:text>
+		<xsl:variable name="valueColor2">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,4,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="$valueColor2 div 15"/>
+	</xsl:when>
+	<xsl:when test="starts-with($colora,'#') and string-length($colora)=7">
+		<xsl:variable name="valueColor1">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,2,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:variable name="valueColor2">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,3,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="($valueColor1*16 + $valueColor2) div 255"/><xsl:text>,</xsl:text>
+		<xsl:variable name="valueColor1a">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,4,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:variable name="valueColor2a">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,5,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="($valueColor1a*16 + $valueColor2a) div 255"/><xsl:text>,</xsl:text>
+		<xsl:variable name="valueColor1b">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,6,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:variable name="valueColor2b">
+			<xsl:call-template name="Hex2Decimal">
+				<xsl:with-param name="arg" select="substring($colora,7,1)"/>
+			</xsl:call-template>
+		</xsl:variable>
+		<xsl:value-of select="($valueColor1b*16 + $valueColor2b) div 255"/>
+	</xsl:when>
+<!-- ======================= if color specifed as an html-color-name ========================================== -->
+	<xsl:when test="$colora='aqua'"><xsl:text>0,1,1</xsl:text></xsl:when>
+	<xsl:when test="$colora='black'"><xsl:text>0,0,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='blue'"><xsl:text>0,0,1</xsl:text></xsl:when>
+	<xsl:when test="$colora='fuchsia'"><xsl:text>1,0,1</xsl:text></xsl:when>
+	<xsl:when test="$colora='gray'"><xsl:text>.5,.5,.5</xsl:text></xsl:when>
+	<xsl:when test="$colora='green'"><xsl:text>0,.5,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='lime'"><xsl:text>0,1,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='maroon'"><xsl:text>.5,0,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='navy'"><xsl:text>0,0,.5</xsl:text></xsl:when>
+	<xsl:when test="$colora='olive'"><xsl:text>.5,.5,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='purple'"><xsl:text>.5,0,.5</xsl:text></xsl:when>
+	<xsl:when test="$colora='red'"><xsl:text>1,0,0</xsl:text></xsl:when>
+	<xsl:when test="$colora='silver'"><xsl:text>.75,.75,.75</xsl:text></xsl:when>
+	<xsl:when test="$colora='teal'"><xsl:text>0,.5,.5</xsl:text></xsl:when>
+	<xsl:when test="$colora='white'"><xsl:text>1,1,1</xsl:text></xsl:when>
+	<xsl:when test="$colora='yellow'"><xsl:text>1,1,0</xsl:text></xsl:when>
+	<xsl:otherwise>
+		<xsl:message>Exception at color template</xsl:message>
+	</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template name="Hex2Decimal">
+	<xsl:param name="arg"/>
+	<xsl:choose>
+		<xsl:when test="$arg='f'">
+			<xsl:value-of select="15"/>
+		</xsl:when>
+		<xsl:when test="$arg='e'">
+			<xsl:value-of select="14"/>
+		</xsl:when>
+		<xsl:when test="$arg='d'">
+			<xsl:value-of select="13"/>
+		</xsl:when>
+		<xsl:when test="$arg='c'">
+			<xsl:value-of select="12"/>
+		</xsl:when>
+		<xsl:when test="$arg='b'">
+			<xsl:value-of select="11"/>
+		</xsl:when>
+		<xsl:when test="$arg='a'">
+			<xsl:value-of select="10"/>
+		</xsl:when>
+		<xsl:when test="translate($arg, '0123456789', '9999999999')='9'"> <!-- if $arg is number -->
+			<xsl:value-of select="$arg"/>
+		</xsl:when>
+		<xsl:otherwise>
+			<xsl:message>Exception at Hex2Decimal template</xsl:message>
+		</xsl:otherwise>
+	</xsl:choose>
+</xsl:template>
+<xsl:template match="m:*/text()">
+	<xsl:call-template name="replaceEntities">
+		<xsl:with-param name="content" select="normalize-space()"/>
+	</xsl:call-template>
+</xsl:template>
+</xsl:stylesheet>

ultradata_math_parser/parsers/__init__.py ADDED Viewed

	@@ -0,0 +1,15 @@

+# -*- coding:utf-8 -*-
+from ultradata_math_parser.parsers.article_parser import ArticleParser
+from ultradata_math_parser.parsers.forum_parser import ForumParser
+from ultradata_math_parser.parsers.custom_parser import CustomParser
+from ultradata_math_parser.parsers.unified_parser import UnifiedParser
+from ultradata_math_parser.parsers.title_parser import TitleParser
+__all__ = [
+    "ArticleParser",
+    "ForumParser",
+    "CustomParser",
+    "UnifiedParser",
+    "TitleParser",
+]

ultradata_math_parser/parsers/article_parser.py ADDED Viewed

	@@ -0,0 +1,76 @@

+# -*- coding:utf-8 -*-
+from copy import deepcopy
+from ultradata_math_parser.utils import *
+from ultradata_math_parser.parsers.base_parser import BaseParser
+from ultradata_math_parser.parsers.title_parser import TitleParser
+class ArticleParser(BaseParser):
+    def __init__(self) -> None:
+        super().__init__()
+    def extract(self, html="", **kwargs) -> dict:
+        base_url = kwargs.get("base_url", "")
+        self.process_math = kwargs.get("process_math", self.process_math)
+        self.preserve_math_containers = kwargs.get("preserve_math_containers", self.preserve_math_containers)
+        self.include_tables = kwargs.get("include_tables", self.include_tables)
+        self.include_images = kwargs.get("include_images", self.include_images)
+        html = html.replace("&nbsp;", " ").replace("&#160;", " ")
+        tree = load_html(html)
+        if tree is None:
+            raise ValueError
+        title = TitleParser().process(tree)
+        # base_url
+        base_href = tree.xpath("//base/@href")
+        if base_href and "http" in base_href[0]:
+            base_url = base_href[0]
+        if "://blog.csdn.net/" in base_url:
+            for dtree in tree.xpath('//div[@id="content_views"]//ul[@class="pre-numbering"]'):
+                self.remove_node(dtree)
+        raw_tree = deepcopy(tree)
+        working_tree = deepcopy(tree)
+        # 标签转换, 增加数学标签处理
+        format_tree = self.convert_tags(working_tree, base_url=base_url)
+        format_tree = self._remove_tables_from_tree(format_tree)
+        format_tree = self._remove_images_from_tree(format_tree)
+        # 删除script style等标签及其内容
+        normal_tree = self.clean_tags(format_tree)
+        normal_tree = self._remove_tables_from_tree(normal_tree)
+        normal_tree = self._remove_images_from_tree(normal_tree)
+        fallback_tree = deepcopy(normal_tree)
+        subtree, xp_num, drop_list = self.xp_1_5(normal_tree)
+        if xp_num == "others":
+            subtree, drop_list = self.prune_unwanted_sections(normal_tree)
+        body_html = self.get_content_html(subtree, xp_num, base_url)
+        body_html, fallback_strategy = self.apply_fallbacks(
+            primary_html=body_html,
+            base_url=base_url,
+            normal_tree=fallback_tree,
+            raw_tree=raw_tree,
+        )
+        body_html = self._strip_tables_from_html(body_html)
+        body_html = self._strip_images_from_html(body_html)
+        text_length = self._text_length_from_html(body_html)
+        return {
+            "xp_num": xp_num,
+            "drop_list": drop_list,
+            "html": body_html,
+            "title": title,
+            "base_url": base_url,
+            "fallback_strategy": fallback_strategy,
+            "text_length": text_length,
+        }

ultradata_math_parser/parsers/base_parser.py ADDED Viewed

	@@ -0,0 +1,1059 @@

+# -*- coding:utf-8 -*-
+import html
+import logging
+from collections import defaultdict
+from copy import deepcopy
+from urllib.parse import unquote, urljoin
+from lxml.etree import Comment, strip_elements
+from ultradata_math_parser.config import *
+from ultradata_math_parser.readability_plus import Document as DocumentPlus
+from ultradata_math_parser.utils import *
+class BaseParser:
+    def __init__(self):
+        self.drop_ids = []
+        self.need_comment = False
+        self.process_math = True
+        self.preserve_math_containers = True
+        self.include_tables = True
+        self.include_images = False
+        self.fallback_min_length = 250
+        self.enable_wild_text_fallback = True
+        self.enable_readability_fallback = True
+        self._logger = logging.getLogger(__name__)
+    def xp_1_5(self, tree: HtmlElement):
+        drop_list = False
+        xp_num = "others"
+        result_body = Element("body")
+        for idx, expr in enumerate(BODY_XPATH):
+            try:
+                subtree = tree.xpath(expr)[0]
+                xp_num = str(idx + 1)
+            except IndexError:
+                continue
+            subtree, drop_list = self.prune_unwanted_sections(subtree)
+            if len(subtree) == 0:
+                xp_num = "others"
+                continue
+            ptest = subtree.xpath(".//text()[not(ancestor::a)]")
+            ptest_len = text_len("".join(ptest))
+            all_text_len = text_len(
+                "".join(tree.xpath("//p//text()[not(ancestor::a)]"))
+            )
+            if drop_list:
+                if ptest_len <= 50:
+                    if all_text_len > 100:
+                        xp_num = "others"
+                    continue
+            else:
+                if ptest_len <= 20:
+                    if all_text_len > 100:
+                        xp_num = "others"
+                    continue
+            result_body.append(subtree)
+            return result_body, xp_num, drop_list
+        return result_body, xp_num, drop_list
+    def get_content_html(self, cleaned_tree_backup, xp_num="others", base_url=""):
+        # readability_plus
+        doc = DocumentPlus(
+            cleaned_tree_backup,
+            url=base_url,
+            xp_num=xp_num,
+            need_comment=self.need_comment,
+        )
+        body = doc.summary(html_partial=True)
+        return body
+    def _text_length_from_html(self, html_fragment):
+        if not html_fragment:
+            return 0
+        # 使用 lxml.html.fromstring 解析后提取 text_content
+        # 不再依赖 w3m
+        try:
+            tree = fromstring(html_fragment)
+            text = tree.text_content()
+            return len(text or "")
+        except Exception:
+            return 0
+    def _is_content_sufficient(self, html_fragment):
+        return self._text_length_from_html(html_fragment) >= self.fallback_min_length
+    def _remove_tables_from_tree(self, tree: HtmlElement) -> HtmlElement:
+        if self.include_tables:
+            return tree
+        for table in list(tree.xpath(".//table")):
+            parent = table.getparent()
+            if parent is not None:
+                parent.remove(table)
+        return tree
+    def _strip_tables_from_html(self, html_fragment: str) -> str:
+        if self.include_tables or not html_fragment:
+            return html_fragment
+        try:
+            wrapper = fromstring(f"<div>{html_fragment}</div>")
+        except Exception:
+            return html_fragment
+        self._remove_tables_from_tree(wrapper)
+        return "".join(tostring(child, encoding=str) for child in wrapper)
+    def _remove_images_from_tree(self, tree: HtmlElement) -> HtmlElement:
+        for node in list(tree.xpath(".//img|.//picture|.//source")):
+            # 在删除IMG之前，检查ALT是否包含LaTeX公式
+            if node.tag == "img":
+                alt = node.get("alt", "")
+                src = node.get("src", "")
+                if alt:
+                    # URL解码（处理 &space; 等编码）
+                    alt_decoded = unquote(alt.replace('&space;', ' ').replace('&#92;', '\\'))
+                    # 检测ALT是否包含LaTeX特征
+                    is_latex = False
+                    # 1. 以$开头结尾
+                    if alt_decoded.strip().startswith('$') and len(alt_decoded.strip()) > 2:
+                        is_latex = True
+                    # 2. 以\[开头或\]结尾 (display math)
+                    elif alt_decoded.strip().startswith('\\[') or alt_decoded.strip().endswith('\\]'):
+                        is_latex = True
+                    # 3. 包含LaTeX命令 (\frac, \sum, \alpha等)
+                    elif re.search(r'\\[a-zA-Z]+', alt_decoded):
+                        is_latex = True
+                    # 4. 包含上下标
+                    elif re.search(r'\^|_\{|_[a-zA-Z0-9]', alt_decoded):
+                        is_latex = True
+                    # 5. src包含latex相关关键词（作为辅助判断）
+                    elif any(kw in src.lower() for kw in ['latex', 'codecogs', 'math', 'tex', 'equation']):
+                        if len(alt_decoded.strip()) > 1:
+                            is_latex = True
+                    if is_latex:
+                        # 创建span保存LaTeX公式
+                        new_span = Element("span")
+                        # 确保公式被正确包装
+                        if alt_decoded.strip().startswith('$') or alt_decoded.strip().startswith('\\['):
+                            new_span.text = alt_decoded
+                        else:
+                            new_span.text = wrap_math(alt_decoded)
+                        # 在img之前插入span
+                        parent = node.getparent()
+                        if parent is not None:
+                            node.addprevious(new_span)
+            # 删除图片节点
+            parent = node.getparent()
+            if parent is not None:
+                parent.remove(node)
+        for html_map in list(tree.xpath(".//map")):
+            parent = html_map.getparent()
+            if parent is not None:
+                parent.remove(html_map)
+        return tree
+    def _strip_images_from_html(self, html_fragment: str) -> str:
+        if not html_fragment:
+            return html_fragment
+        try:
+            wrapper = fromstring(f"<div>{html_fragment}</div>")
+        except Exception:
+            return html_fragment
+        self._remove_images_from_tree(wrapper)
+        return "".join(tostring(child, encoding=str) for child in wrapper)
+    def recover_wild_text(self, tree, base_url="", aggressive=False):
+        if tree is None:
+            return None
+        working_tree = deepcopy(tree)
+        try:
+            pruned_tree, _ = self.prune_unwanted_sections(working_tree)
+        except Exception:
+            pruned_tree = working_tree
+        search_expr = ".//p|.//pre|.//code|.//blockquote|.//q|.//quote"
+        if self.include_tables:
+            search_expr += "|.//table"
+        if aggressive:
+            search_expr += "|.//div|.//section|.//article|.//li"
+        try:
+            nodes = pruned_tree.xpath(search_expr)
+        except Exception:
+            nodes = []
+        if not nodes:
+            return None
+        container = Element("div")
+        seen_texts = set()
+        for node in nodes:
+            try:
+                text_value = trim(node.text_content())
+            except Exception:
+                text_value = None
+            if not text_value:
+                continue
+            if text_len(text_value) < 10:
+                continue
+            if text_value in seen_texts:
+                continue
+            seen_texts.add(text_value)
+            if node.tag == "table":
+                if self.include_tables:
+                    container.append(deepcopy(node))
+                continue
+            else:
+                paragraph = Element("p")
+                paragraph.text = text_value
+                container.append(paragraph)
+        if len(container) == 0:
+            return None
+        return tostring(container, encoding=str)
+    def readability_fallback(self, tree, base_url=""):
+        if tree is None:
+            return None
+        try:
+            doc = DocumentPlus(
+                deepcopy(tree),
+                url=base_url,
+                xp_num="others",
+                need_comment=self.need_comment,
+            )
+            return doc.summary(html_partial=True)
+        except Exception:
+            return None
+    def apply_fallbacks(self, primary_html, base_url, normal_tree, raw_tree):
+        if self._is_content_sufficient(primary_html):
+            return primary_html, "primary"
+        wild_html = None
+        if self.enable_wild_text_fallback:
+            wild_html = self.recover_wild_text(normal_tree, base_url)
+            if self._is_content_sufficient(wild_html):
+                return wild_html, "wild_text"
+        readability_html = None
+        if self.enable_readability_fallback:
+            readability_html = self.readability_fallback(raw_tree, base_url)
+            if self._is_content_sufficient(readability_html):
+                return readability_html, "readability"
+        for candidate, name in (
+            (primary_html, "primary"),
+            (wild_html, "wild_text"),
+            (readability_html, "readability"),
+        ):
+            if candidate:
+                return candidate, name
+        return "", "primary"
+    def prune_unwanted_nodes(self, tree, nodelist, with_backup=False):
+        if with_backup is True:
+            old_len = len(tree.text_content())
+            backup = deepcopy(tree)
+        for expr in nodelist:
+            for subtree in tree.xpath(expr):
+                if self.preserve_math_containers and subtree.xpath(".//math"):
+                    continue
+                # DISCARD_IMAGE_ELEMENTS 需要特殊判断
+                if '"caption"' in expr and subtree.xpath(".//img"):
+                    continue
+                # 有些出现hidden
+                if "hidden" in expr:
+                    try:
+                        if re.findall(
+                                "overflow-x:\s*hidden", subtree.attrib["style"]
+                        ) or re.findall(
+                            "overflow-y:\s*hidden", subtree.attrib["style"]
+                        ):
+                            continue
+                        if re.findall(
+                                "overflow:\s*hidden", subtree.attrib["style"]
+                        ) and re.findall("height:", subtree.attrib["style"]):
+                            height_px = re.findall(
+                                "height:\s*(\d+)", subtree.attrib["style"]
+                            )[0]
+                            if int(height_px) >= 800:
+                                continue
+                    except:
+                        pass
+                if ancestor_node_check(subtree, ['code', 'pre']):
+                    continue
+                self.remove_node(subtree)
+        if with_backup is False:
+            return tree
+        # else:
+        new_len = len(tree.text_content())
+        if new_len > old_len / 7:
+            return tree
+        return backup
+    def prune_html(self, tree):
+        """Delete selected empty elements"""
+        for element in tree.xpath(".//*[not(node())]"):
+            if element.tag in CUT_EMPTY_ELEMS:
+                self.remove_node(element)
+        return tree
+    def remove_node(self, node: HtmlElement):
+        parent = node.getparent()
+        if text_strip(node.tail):
+            previous = node.getprevious()
+            if previous is None:
+                if parent is not None:
+                    if text_strip(parent.text):
+                        parent.text = "".join([parent.text, node.tail])
+                    else:
+                        parent.text = node.tail
+            else:
+                if text_strip(previous.tail):
+                    previous.tail = "".join([previous.tail, node.tail])
+                else:
+                    previous.tail = node.tail
+        if parent is not None:
+            idx = node.attrib.get(Unique_ID, "")
+            parent.remove(node)
+            if idx:
+                self.drop_ids.append(int(idx))
+    def clean_tags(self, tree):
+        strip_elements(tree, Comment)
+        xp_lists = []
+        if not self.need_comment:
+            xp_lists.append(REMOVE_COMMENTS_XPATH)
+        xp_lists.append(CONTENT_EXTRACTOR_NOISE_XPATHS)
+        for xp_list in xp_lists:
+            tree = self.prune_unwanted_nodes(tree, xp_list)
+        cleaning_list, stripping_list = (
+            MANUALLY_CLEANED.copy(),
+            MANUALLY_STRIPPED.copy(),
+        )
+        for elem in tree.xpath(".//figure[descendant::table]"):
+            elem.tag = "div"
+        for expression in cleaning_list + ["form"]:
+            for element in tree.getiterator(expression):
+                if self.preserve_math_containers and element.xpath('.//math'):
+                    continue
+                # 针对form 标签特殊处理
+                if element.tag == "form":
+                    ptest = element.xpath(".//text()[not(ancestor::a)]")
+                    if text_len("".join(ptest)) <= 60:  # 50
+                        self.remove_node(element)
+                else:
+                    self.remove_node(element)
+        HTML_CLEANER.kill_tags, HTML_CLEANER.remove_tags = cleaning_list, stripping_list
+        cleaned_tree = HTML_CLEANER.clean_html(self.prune_html(tree))
+        return cleaned_tree
+    def generate_unique_id(self, element):
+        idx = 0
+        for node in iter_node(element):
+            l_tag = node.tag.lower()
+            if l_tag not in ["html", "body"]:
+                node.attrib[Unique_ID] = str(idx)
+                idx += 1
+    def clean_unique_id(self, raw_element, content_html):
+        ids = re.findall(f' {Unique_ID}="(\d+)"', content_html)
+        self.drop_ids = list(set(self.drop_ids))
+        self.drop_ids.sort()
+        skip_ids = [-1]
+        for x in ids:
+            if int(x) > int(skip_ids[-1]):
+                skip_ids.append(int(x))
+                drop_node = raw_element.xpath(
+                    f"//*[@{Unique_ID}='{x}']"
+                )
+                if drop_node:
+                    new_div = Element("div")
+                    for j in self.drop_ids:
+                        if int(j) > int(skip_ids[-1]):
+                            append_element = drop_node[0].xpath(
+                                f".//*[@{Unique_ID}='{j}']"
+                            )
+                            if append_element:
+                                skip_ids.append(j)
+                                if len(append_element[0]) > 0:
+                                    skip_ids.extend(
+                                        [
+                                            int(pjid)
+                                            for pjid in append_element[0].xpath(
+                                            f".//*/@{Unique_ID}"
+                                        )
+                                        ]
+                                    )
+                                append_element[0].tail = None
+                                new_div.append(append_element[0])
+                    try:
+                        drop_node[0].addnext(new_div)
+                        parent = drop_node[0].getparent()
+                        if parent is not None:
+                            parent.remove(drop_node[0])
+                    except:
+                        pass
+        content_html = re.sub(f' {Unique_ID}="\d+"', "", content_html)
+        drop_html = re.sub(
+            f' {Unique_ID}="\d+"',
+            "",
+            tostring(raw_element, encoding=str),
+        )
+        return content_html, drop_html
+    def math_latex_processing(self, node):
+        # 1. 文本中有\\begin{align} 或 \\begin{equation}
+        if node.tag not in ["script", "style"] and text_strip(node.text):
+            regex = r"\\begin{align}(.*?)\\end{align}"
+            text = node.text
+            matches = re.findall(regex, text, re.DOTALL)
+            if matches:
+                node.text = text.replace("\\begin{align}", "").replace(
+                    "\\end{align}", ""
+                )
+        if node.tag not in ["script", "style"] and text_strip(node.text):
+            regex = r"\\begin{equation}(.*?)\\end{equation}"
+            text = node.text
+            matches = re.findall(regex, text, re.DOTALL)
+            for match in matches:
+                match = match.replace("\\begin{equation}", "")
+                match = match.replace("\\end{equation}", "")
+                wrapped_text = wrap_math(match, display=True)
+                text = text.replace(match, wrapped_text)
+            if matches:
+                # Remove the \begin{equation} and \end{equation} tags
+                text = text.replace("\\begin{equation}", "").replace(
+                    "\\end{equation}", ""
+                )
+                node.text = text
+        if node.tag not in ["script", "style"] and text_strip(node.tail):
+            regex = r"\\begin{align}(.*?)\\end{align}"
+            text = node.tail
+            matches = re.findall(regex, text, re.DOTALL)
+            if matches:
+                node.tail = text.replace("\\begin{align}", "").replace(
+                    "\\end{align}", ""
+                )
+        if node.tag not in ["script", "style"] and text_strip(node.tail):
+            regex = r"\\begin{equation}(.*?)\\end{equation}"
+            text = node.tail
+            matches = re.findall(regex, text, re.DOTALL)
+            for match in matches:
+                match = match.replace("\\begin{equation}", "")
+                match = match.replace("\\end{equation}", "")
+                wrapped_text = wrap_math(match, display=True)
+                text = text.replace(match, wrapped_text)
+            if matches:
+                # Remove the \begin{equation} and \end{equation} tags
+                text = text.replace("\\begin{equation}", "").replace(
+                    "\\end{equation}", ""
+                )
+                node.tail = text
+        node_class = node.get("class")
+        parent = node.getparent()
+        # 2. class 为 texerror 的标签
+        # Find the text between {} (maximum length) and replace the texerror with that text
+        # 3. img中的latex
+        if node.tag == "img":
+            if node_class:
+                class_list = node_class.split(" ")
+                if any(
+                        [img_class in class_list for img_class in latex_image_class_names]
+                ):
+                    alt = node.get("alt")
+                    if text_strip(alt):
+                        new_span = Element("span")
+                        wrapped_alt = wrap_math(alt)
+                        new_span.text = wrapped_alt
+                        node.addprevious(new_span)
+                        self.remove_node(node)
+            src = node.get("src")
+            if src:
+                if "codecogs.com" in src:
+                    try:
+                        latex = src.split("?")[1:]
+                        latex = "?".join(
+                            latex
+                        )  # In case there are multiple ? in the latex
+                        latex = unquote(latex)
+                        new_span = Element("span")
+                        wrapped_latex = wrap_math(latex)
+                        new_span.text = wrapped_latex
+                        node.addprevious(new_span)
+                        self.remove_node(node)
+                    except:
+                        pass
+                if "latex.php" in src:
+                    try:
+                        # they usually have "alt='-i u_t + &#92;Delta u = |u|^2 u'"
+                        alt = node.get("alt")
+                        if text_strip(alt):
+                            # Unescape the latex
+                            alt = unquote(alt)
+                            # Get the latex
+                            wrapped_alt = wrap_math(alt)
+                            new_span = Element("span")
+                            new_span.text = wrapped_alt
+                            node.addprevious(new_span)
+                            self.remove_node(node)
+                    except:
+                        pass
+                if "/images/math/codecogs" in src:
+                    try:
+                        # they usually have "alt='-i u_t + &#92;Delta u = |u|^2 u'"
+                        alt = node.get("alt")
+                        if text_strip(alt):
+                            # Unescape the latex
+                            alt = unquote(alt)
+                            # Get the latex
+                            wrapped_alt = wrap_math(alt)
+                            new_span = Element("span")
+                            new_span.text = wrapped_alt
+                            node.addprevious(new_span)
+                            self.remove_node(node)
+                    except:
+                        pass
+                if "mimetex.cgi" in src:
+                    try:
+                        latex = src.split("?")[1:]
+                        latex = "?".join(
+                            latex
+                        )  # In case there are multiple ? in the latex
+                        latex = unquote(latex)
+                        new_span = Element("span")
+                        wrapped_latex = wrap_math(latex)
+                        new_span.text = wrapped_latex
+                        node.addprevious(new_span)
+                        self.remove_node(node)
+                    except:
+                        pass
+                if "mathtex.cgi" in src:
+                    try:
+                        latex = src.split("?")[1:]
+                        latex = "?".join(
+                            latex
+                        )  # In case there are multiple ? in the latex
+                        latex = unquote(latex)
+                        new_span = Element("span")
+                        wrapped_latex = wrap_math(latex)
+                        new_span.text = wrapped_latex
+                        node.addprevious(new_span)
+                        self.remove_node(node)
+                    except:
+                        pass
+            if node_class:
+                if "x-ck12" in node_class:
+                    try:
+                        latex = node.get("alt")
+                        if text_strip(latex):
+                            latex = unquote(latex)
+                            new_span = Element("span")
+                            wrapped_latex = wrap_math(latex)
+                            new_span.text = wrapped_latex
+                            node.addprevious(new_span)
+                    except:
+                        pass
+        # 4. class 为 math-container
+        if node_class == "math-container":
+            try:
+                text = node.text
+                if text_strip(text):
+                    new_span = Element("span")
+                    wrapped_math = wrap_math(text, display=True)
+                    new_span.text = wrapped_math
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+            except:
+                pass
+        # 5. class 为 wp-katex-eq
+        if node_class == "wp-katex-eq":
+            try:
+                text = node.text
+                if text_strip(text):
+                    new_span = Element("span")
+                    display_attr = node.get("data-display")
+                    if display_attr is not None:
+                        display = display_attr == "true"
+                    else:
+                        display = False
+                    wrapped_math = wrap_math(text, display=display)
+                    new_span.text = wrapped_math
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+            except:
+                pass
+        # 6. script[type="math/tex"]
+        if node.tag == "script" and node.get("type") == "math/tex":
+            try:
+                text = node.text
+                if text_strip(text):
+                    new_span = Element("span")
+                    wrapped_text = wrap_math(text)
+                    new_span.text = wrapped_text
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+            except:
+                pass
+        # 7. script[type="math/asciimath"]
+        if node.tag == "script" and node.get("type") == "math/asciimath":
+            try:
+                text = node.text
+                if text_strip(text):
+                    new_span = Element("span")
+                    wrapped_asciimath = wrap_math(extract_asciimath(text))
+                    new_span.text = wrapped_asciimath
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+            except:
+                # Delete this script tag
+                self.remove_node(node)
+        # 8. class tex
+        if node_class == "tex":
+            try:
+                # Check if they have data-expr attr
+                expr = node.get("data-expr")
+                if text_strip(expr):
+                    # Replace with a span
+                    new_span = Element("span")
+                    wrapped_expr = wrap_math(expr)
+                    new_span.text = wrapped_expr
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+            except:
+                pass
+        # 9. span.katex
+        if node.tag == "span" and node_class == "katex":
+            # Find any spans with class "katex-html" and remove them
+            katex_html_spans = node.xpath('.//span[@class="katex-html"]')
+            for katex_html_span in katex_html_spans:
+                self.remove_node(katex_html_span)
+        # 10. Remove any .MathJax_Preview spans
+        if node.tag == "span" and node_class == "MathJax_Preview":
+            self.remove_node(node)
+        if node.tag == "span" and node_class and "x-ck12-mathEditor" in node_class:
+            try:
+                expr = node.get("data-tex")
+                if text_strip(expr):
+                    expr = unquote(expr).replace("\&quot;", "").replace("&quot;", "")
+                    # Replace with a span
+                    new_span = Element("span")
+                    wrapped_expr = wrap_math(expr)
+                    new_span.text = wrapped_expr
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+            except:
+                pass
+        # 11. all math tags
+        if node.tag == "math":
+            annotation_tags = node.xpath('.//annotation[@encoding="application/x-tex"]')
+            if len(annotation_tags) > 0:
+                annotation_tag = annotation_tags[0]
+                text = annotation_tag.text
+                if text_strip(text):
+                    new_span = Element("span")
+                    wrapped_text = wrap_math(text)
+                    new_span.text = wrapped_text
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+                    style_value = parent.get("style")
+                    if style_value:
+                        normalized_style_value = (
+                            style_value.lower()
+                            .strip()
+                            .replace(" ", "")
+                            .replace(";", "")
+                        )
+                        if "display:none" in normalized_style_value:
+                            parent.style = ""
+            elif text_strip(node.get("alttext")):
+                # Get the alttext attribute
+                alttext = node.get("alttext")
+                if text_strip(alttext):
+                    new_span = Element("span")
+                    wrapped_alttext = wrap_math(alttext)
+                    new_span.text = wrapped_alttext
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+            else:
+                try:
+                    # Try translating to LaTeX
+                    tmp_node = deepcopy(node)
+                    tmp_node.tail = None
+                    mathml = tostring(tmp_node, encoding=str)
+                    # If this includes xmlns:mml, then we need to replace all
+                    # instances of mml: with nothing
+                    if "xmlns:mml" in mathml:
+                        mathml = mathml.replace("mml:", "")
+                        # replace xmlns:mml="..." with nothing
+                        mathml = re.sub(r'xmlns:mml=".*?"', "", mathml)
+                    # if 'xmlns=' in mathml:
+                    #     mathml = re.sub(r"xmlns='.*?'", '', mathml)
+                    latex = mml_to_latex(mathml)
+                    # Make a new span tag
+                    new_span = Element("span")
+                    # Set the html of the new span tag to the text
+                    wrapped_latex = wrap_math(latex)
+                    new_span.text = wrapped_latex
+                    # Then, we need to replace the math tag with the new span tag
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+                except:
+                    self.remove_node(node)
+        if node.tag == "mathjax":
+            try:
+                # Get the inner text of the mathjax tag
+                text = node.text
+                if text_strip(text):
+                    text = html.unescape(text)
+                    # Use regex to find text wrapped in hashes
+                    matches = re.findall(r"#(.+?)#", text)
+                    # For each match, replace the match with the LaTeX
+                    for match in matches:
+                        try:
+                            latex = extract_asciimath(match)
+                            # Replace the match with the LaTeX
+                            text = text.replace(f"#{match}#", latex)
+                        except:
+                            pass
+                    # Create a new span tag
+                    new_span = Element("span")
+                    # Set the html of the new span tag to the text
+                    new_span.text = text
+                    # Then, we need to replace the mathjax tag with the new span tag
+                    if parent is not None:
+                        if text_strip(node.tail):
+                            new_span.tail = node.tail
+                        parent.replace(node, new_span)
+            except:
+                pass
+    def convert_tags(self, element, base_url=""):
+        USELESS_ATTR_LIST = USELESS_ATTR
+        if not self.need_comment:
+            USELESS_ATTR_LIST = USELESS_ATTR_LIST + ["comment"]
+        for node in iter_node(element):
+            if self.process_math:
+                # 增加数学标签转换
+                self.math_latex_processing(node)
+            if "data-src" in node.attrib and "src" not in node.attrib:
+                node.attrib["src"] = node.attrib["data-src"]
+            if "src" in node.attrib and node.attrib["src"] and base_url:
+                src_url = node.attrib["src"]
+                absolute_url = urljoin(base_url, src_url)
+                node.attrib["src"] = absolute_url
+            if node.tag.lower() == "div" and not node.getchildren():
+                node.tag = "p"
+            class_name = node.get("class")
+            if class_name:
+                if class_name.lower() in USELESS_ATTR_LIST:
+                    self.remove_node(node)
+        return element
+    def delete_by_link_density(
+            self, subtree, tagname, backtracking=False, favor_precision=False
+    ):
+        need_del_par = []
+        skip_par = []
+        drop_list = False
+        for descendant in subtree.iter(tagname):
+            pparent = descendant.getparent()
+            if pparent in need_del_par or pparent in skip_par:
+                continue
+            siblings = descendant.xpath(f"following-sibling::{tagname}")
+            if 'list' in descendant.get("class", "") and len(descendant.xpath('./a')) >= 5:
+                need_del_par.append(descendant)
+                need_del_par.extend(siblings)
+                continue
+            nn = [descendant]
+            nn.extend(siblings)
+            txt_max_num = 0
+            if len(siblings) + 1 >= 4:
+                pass
+            else:
+                txt_max_dict = {
+                    "read": 0,
+                    "more": 0,
+                    "...": 0,
+                    "阅读": 0,
+                    "更多": 0,
+                    "详细": 0,
+                    "detail": 0,
+                    "article": 0,
+                    "blog": 0,
+                    "news": 0,
+                }
+                if tagname == "div" or tagname == "article" or tagname == "section":
+                    for j in nn:
+                        txt = "".join(j.xpath(".//text()")).strip()
+                        for x in [
+                            "read",
+                            "more",
+                            "...",
+                            "阅读",
+                            "更多",
+                            "详细",
+                            "detail",
+                            "article",
+                            "blog",
+                            "news",
+                        ]:
+                            if txt.lower().endswith(x):
+                                txt_max_dict[x] += 1
+                        txt_num = max(txt_max_dict.values())
+                        if txt_max_num < txt_num:
+                            txt_max_num = txt_num
+                        if txt_max_num >= 3:
+                            break
+                if txt_max_num >= 3:
+                    pass
+                else:
+                    continue
+            skip_par.append(pparent)
+            a_num = 0
+            for j in siblings:
+                if j.xpath(".//a"):
+                    if tagname == "p":
+                        if density_of_a_text(j, pre=0.8):
+                            a_num += 1
+                    elif tagname in ["div", "section", "article"]:
+                        if density_of_a_text(j, pre=0.2):
+                            a_num += 1
+                    else:
+                        if self.need_comment:
+                            # 增加判断是否包含评论 再决定是否删除
+                            break_flg = False
+                            for c_xpath in Forum_XPATH[:-1]:
+                                if j.xpath(c_xpath.replace(".//*", "self::*")):
+                                    break_flg = True
+                                    break
+                            if break_flg:
+                                continue
+                        if tagname == "li":
+                            if text_len("".join(j.xpath(".//text()[not(ancestor::a)]"))) > 50:
+                                continue
+                        a_num += 1
+            if a_num < len(siblings):
+                if a_num >= 15 and (
+                        tagname == "div" or tagname == "article" or tagname == "section"
+                ):
+                    pass
+                else:
+                    continue
+            similarity_with_siblings_nums = similarity_with_siblings(
+                descendant, siblings
+            )
+            if tagname == "article" or tagname == "item":  # or tagname == "section"
+                similarity_with_siblings_nums = similarity_with_siblings_nums * 1.5
+            # 列表有个很特殊的地方 另一种情况就是 descendant和siblings 都包含title/h1 | h2 标签
+            if tagname == "div" or tagname == "article" or tagname == "section":
+                title_max_num = 0
+                for ll in [".//head[@rend='h2']", ".//head[@rend='h1']", "./article"]:
+                    title_num = 0
+                    for jj in nn:
+                        if jj.xpath(ll):
+                            title_num += 1
+                    if title_max_num < title_num:
+                        title_max_num = title_num
+                if title_max_num >= 4:
+                    similarity_with_siblings_nums = similarity_with_siblings_nums * 1.5
+            if txt_max_num >= 3:
+                pass
+            elif similarity_with_siblings_nums < 0.84:
+                if len(siblings) >= 15 and (
+                        tagname == "div" or tagname == "article" or tagname == "section"
+                ):
+                    pass
+                else:
+                    continue
+            # 父div中包含多同级div 且div class post-时，删除其余节点，保留第一篇文章
+            class_attr = descendant.get("class") if descendant.get("class") else ""
+            if (
+                    re.findall("post-", class_attr, re.I)
+                    or re.findall("-post", class_attr, re.I)
+                    or re.findall("blog|aricle", class_attr, re.I)
+            ):
+                drop_list = True
+                sk_flg = True
+                for dl in siblings:
+                    if (
+                            text_len("".join(descendant.xpath(".//text()"))) * 2
+                            < text_len("".join(dl.xpath(".//text()")))
+                            and sk_flg
+                    ):
+                        self.remove_node(descendant)
+                        sk_flg = False
+                    else:
+                        self.remove_node(dl)
+            else:
+                need_del_par.append(descendant)
+                need_del_par.extend(siblings)
+        for node in need_del_par:
+            drop_list = True
+            try:
+                self.remove_node(node)
+            except Exception as e:
+                pass
+        myelems, deletions = defaultdict(list), []
+        if tagname == "div":
+            for elem in subtree.iter(tagname):
+                if density_of_a_text(elem, pre=0.8) and img_div_check(elem):
+                    deletions.append(elem)
+        for elem in subtree.iter(tagname):
+            elemtext = trim(elem.text_content())
+            result, templist = link_density_test(elem, elemtext, favor_precision)
+            if result is True and img_div_check(elem):
+                # 保留table中的链接
+                if tagname in ['ul', 'li', 'div', 'p'] and ancestor_node_check(elem, ['td']):
+                    continue
+                deletions.append(elem)
+            elif backtracking is True and len(templist) > 0:  # if?
+                myelems[elemtext].append(elem)
+        if backtracking is True:
+            if favor_precision is False:
+                threshold = 100
+            else:
+                threshold = 200
+            for text, elem in myelems.items():
+                if 0 < len(text) < threshold and len(elem) >= 3:
+                    deletions.extend(elem)
+        for elem in uniquify_list(deletions):
+            try:
+                if self.need_comment:
+                    # 增加判断是否包含评论 再决定是否删除
+                    break_flg = False
+                    for c_xpath in Forum_XPATH[:-1]:
+                        if elem.xpath(c_xpath):
+                            break_flg = True
+                            break
+                    if break_flg:
+                        continue
+                self.remove_node(elem)
+            except AttributeError:
+                pass
+        return subtree, drop_list
+    def prune_unwanted_sections(self, tree):
+        tmp_OVERALL_DISCARD_XPATH = OVERALL_DISCARD_XPATH
+        if self.need_comment:
+            tmp_OVERALL_DISCARD_XPATH = tmp_OVERALL_DISCARD_XPATH[:-1]
+        tree = self.prune_unwanted_nodes(
+            tree, tmp_OVERALL_DISCARD_XPATH, with_backup=True
+        )
+        for xp_list in [
+            PAYWALL_DISCARD_XPATH,
+            TEASER_DISCARD_XPATH,
+            DISCARD_IMAGE_ELEMENTS,
+        ]:
+            tree = self.prune_unwanted_nodes(tree, xp_list)
+        # remove elements by link density
+        tree, drop_list_1 = self.delete_by_link_density(
+            tree, "div", backtracking=True, favor_precision=False
+        )
+        tree, drop_list_1_1 = self.delete_by_link_density(
+            tree, "article", backtracking=False, favor_precision=False
+        )
+        tree, drop_list_1_2 = self.delete_by_link_density(
+            tree, "section", backtracking=False, favor_precision=False
+        )
+        tree, drop_list_2_1 = self.delete_by_link_density(
+            tree, "ul", backtracking=False, favor_precision=False
+        )
+        tree, drop_list_2_2 = self.delete_by_link_density(
+            tree, "li", backtracking=False, favor_precision=False
+        )
+        tree, drop_list_3_1 = self.delete_by_link_density(
+            tree, "dl", backtracking=False, favor_precision=False
+        )
+        tree, drop_list_3_3 = self.delete_by_link_density(
+            tree, "dt", backtracking=False, favor_precision=False
+        )
+        tree, drop_list_3_2 = self.delete_by_link_density(
+            tree, "dd", backtracking=False, favor_precision=False
+        )
+        tree, drop_list_3 = self.delete_by_link_density(
+            tree, "p", backtracking=False, favor_precision=False
+        )
+        return (
+            tree,
+            drop_list_1
+            or drop_list_2_1
+            or drop_list_2_2
+            or drop_list_3
+            or drop_list_1_1
+            or drop_list_1_2
+            or drop_list_3_1
+            or drop_list_3_2
+            or drop_list_3_3,
+        )

ultradata_math_parser/parsers/custom_parser.py ADDED Viewed

	@@ -0,0 +1,64 @@

+# -*- coding:utf-8 -*-
+import re
+from ultradata_math_parser.utils import *
+from ultradata_math_parser.parsers.base_parser import BaseParser
+from ultradata_math_parser.parsers.title_parser import TitleParser
+class CustomParser(BaseParser):
+    def __init__(self) -> None:
+        super().__init__()
+    def use_clean_rule(self, tree, clean_rules):
+        for clean_rule in clean_rules:
+            for x in tree.xpath(clean_rule):
+                self.remove_node(x)
+        return tree
+    def use_extract_rule(self, tree, extract_rule):
+        if "/text()" in extract_rule["value"]:
+            return "".join(tree.xpath(extract_rule["value"])).strip()
+        return tree.xpath(extract_rule["value"])[0]
+    def extract(self, html="", base_url="", rule={}, **kwargs) -> dict:
+        self.include_images = kwargs.get("include_images", False)
+        tree = load_html(html)
+        if tree is None:
+            raise ValueError
+        # base_url
+        base_href = tree.xpath("//base/@href")
+        if base_href and "http" in base_href[0]:
+            base_url = base_href[0]
+        if "clean" in rule:
+            tree = self.use_clean_rule(tree, rule["clean"])
+        # 获取title
+        if "title" not in rule:
+            title = TitleParser().process(tree)
+        else:
+            title = self.use_extract_rule(tree, rule["title"])
+        # 文章区域
+        try:
+            body_tree = self.use_extract_rule(tree, rule["content"])
+        except:
+            raise ValueError
+        if not self.include_images:
+            self._remove_images_from_tree(body_tree)
+        body_html = tostring(body_tree, encoding=str)
+        body_html = self._strip_images_from_html(body_html)
+        text_length = self._text_length_from_html(body_html)
+        return {
+            "xp_num": "custom",
+            "drop_list": False,
+            "html": body_html,
+            "title": title,
+            "base_url": base_url,
+            "text_length": text_length,
+        }

ultradata_math_parser/parsers/forum_parser.py ADDED Viewed

	@@ -0,0 +1,135 @@

+# -*- coding:utf-8 -*-
+import re
+from ultradata_math_parser.config import Forum_XPATH, Unique_ID
+from ultradata_math_parser.utils import *
+from ultradata_math_parser.parsers.base_parser import BaseParser
+from ultradata_math_parser.parsers.title_parser import TitleParser
+class ForumParser(BaseParser):
+    def __init__(self) -> None:
+        super().__init__()
+    def extract(self, html="", base_url="", **kwargs) -> dict:
+        self.preserve_math_containers = kwargs.get("preserve_math_containers", self.preserve_math_containers)
+        self.process_math = kwargs.get("process_math", self.process_math)
+        self.include_tables = kwargs.get("include_tables", self.include_tables)
+        self.include_images = kwargs.get("include_images", self.include_images)
+        self.need_comment = True
+        html = html.replace("&nbsp;", " ").replace("&#160;", " ")
+        tree = load_html(html)
+        if tree is None:
+            raise ValueError
+        # 获取title
+        title = TitleParser().process(tree)
+        # base_url
+        base_href = tree.xpath("//base/@href")
+        if base_href and "http" in base_href[0]:
+            base_url = base_href[0]
+        self.generate_unique_id(tree)
+        format_tree = self.convert_tags(tree, base_url=base_url)
+        format_tree = self._remove_tables_from_tree(format_tree)
+        format_tree = self._remove_images_from_tree(format_tree)
+        normal_tree = self.clean_tags(format_tree)
+        normal_tree = self._remove_tables_from_tree(normal_tree)
+        normal_tree = self._remove_images_from_tree(normal_tree)
+        subtree, xp_num, drop_list = self.xp_1_5(normal_tree)
+        if xp_num == "others":
+            subtree, drop_list = self.prune_unwanted_sections(normal_tree)
+        body_html = self.get_content_html(subtree, xp_num, base_url)
+        body_html = self._strip_tables_from_html(body_html)
+        body_html = self._strip_images_from_html(body_html)
+        # 论坛等独有
+        body_html_tree = fromstring(body_html)
+        try:
+            body_tree = body_html_tree.body
+        except:
+            body_tree = Element("body")
+            body_tree.extend(body_html_tree)
+        main_ids = body_tree.xpath(f".//@{Unique_ID}")
+        for main_id in main_ids:
+            main_tree = normal_tree.xpath(
+                f".//*[@{Unique_ID}={main_id}]"
+            )
+            if main_tree:
+                self.remove_node(main_tree[0])
+        if not main_ids:
+            main_ids = [-1]
+        if xp_num != "others":
+            normal_tree, _ = self.prune_unwanted_sections(normal_tree)
+        for c_xpath in Forum_XPATH:
+            while normal_tree.xpath(c_xpath):
+                x = normal_tree.xpath(c_xpath)[0]
+                self.remove_node(x)
+                if "'post-'" in c_xpath:
+                    if not (re.findall('post-\d+', x.attrib.get("id", "").lower()) or re.findall('post_\d+',
+                                                                                                 x.attrib.get("id",
+                                                                                                              "").lower())):
+                        continue
+                if (
+                        "header" in x.attrib.get("class", "").lower()
+                        or "header" in x.attrib.get("id", "").lower()
+                ):
+                    continue
+                try:
+                    if int(x.attrib.get(Unique_ID, "0")) > int(
+                            main_ids[-1]
+                    ):
+                        body_tree.append(x)
+                    else:
+                        prefix_div = Element("div")
+                        suffix_div = Element("div")
+                        need_prefix = False
+                        need_suffix = False
+                        while x.xpath(
+                                f".//*[number(@{Unique_ID}) > {int(main_ids[-1])}]"
+                        ):
+                            tmp_x = x.xpath(
+                                f".//*[number(@{Unique_ID}) > {int(main_ids[-1])}]"
+                            )[0]
+                            self.remove_node(tmp_x)
+                            suffix_div.append(tmp_x)
+                            need_suffix = True
+                        while x.xpath(
+                                f".//*[number(@{Unique_ID}) < {int(main_ids[-1])}]"
+                        ):
+                            tmp_x = x.xpath(
+                                f".//*[number(@{Unique_ID}) < {int(main_ids[-1])}]"
+                            )[0]
+                            self.remove_node(tmp_x)
+                            prefix_div.append(tmp_x)
+                            need_prefix = True
+                        if need_prefix:
+                            body_tree.insert(0, prefix_div)
+                        if need_suffix:
+                            body_tree.append(suffix_div)
+                except:
+                    pass
+        body_html = re.sub(
+            f' {Unique_ID}="\d+"',
+            "",
+            tostring(body_tree, encoding=str),
+        )
+        text_length = self._text_length_from_html(body_html)
+        return {
+            "xp_num": xp_num,
+            "drop_list": drop_list,
+            "html": body_html,
+            "title": title,
+            "base_url": base_url,
+            "text_length": text_length,
+        }

ultradata_math_parser/parsers/title_parser.py ADDED Viewed

	@@ -0,0 +1,49 @@

+# -*- coding:utf-8 -*-
+from ultradata_math_parser.utils import *
+from ultradata_math_parser.config import *
+class TitleParser:
+    def extract_by_meta(self, element: HtmlElement):
+        for xpath in METAS:
+            title = element.xpath(xpath)
+            if title:
+                return "".join(title)
+    def extract_by_title(self, element: HtmlElement):
+        return "".join(element.xpath("//title//text()")).strip()
+    def extract_by_hs(self, element: HtmlElement):
+        hs = element.xpath("//h1//text()|//h2//text()|//h3//text()")
+        return hs or []
+    def extract_by_h(self, element: HtmlElement):
+        for xpath in ["//h1", "//h2", "//h3"]:
+            children = element.xpath(xpath)
+            if not children:
+                continue
+            child = children[0]
+            texts = child.xpath("./text()")
+            if texts and len(texts):
+                return texts[0].strip()
+    def process(self, element: HtmlElement):
+        title_extracted_by_meta = self.extract_by_meta(element)
+        if title_extracted_by_meta:
+            return title_extracted_by_meta
+        title_extracted_by_h = self.extract_by_h(element)
+        title_extracted_by_hs = self.extract_by_hs(element)
+        title_extracted_by_title = self.extract_by_title(element)
+        title_extracted_by_hs = sorted(
+            title_extracted_by_hs,
+            key=lambda x: similarity2(x, title_extracted_by_title),
+            reverse=True,
+        )
+        if title_extracted_by_hs:
+            return lcs_of_2(title_extracted_by_hs[0], title_extracted_by_title)
+        if title_extracted_by_title:
+            return title_extracted_by_title
+        return title_extracted_by_h

ultradata_math_parser/parsers/unified_parser.py ADDED Viewed

	@@ -0,0 +1,187 @@

+# -*- coding:utf-8 -*-
+import re
+from copy import deepcopy
+from lxml.html import Element, tostring, fromstring
+from ultradata_math_parser.config import Forum_XPATH, Unique_ID
+from ultradata_math_parser.utils import load_html, text_len
+from ultradata_math_parser.parsers.base_parser import BaseParser
+from ultradata_math_parser.parsers.title_parser import TitleParser
+class UnifiedParser(BaseParser):
+    def __init__(self):
+        super().__init__()
+        self.need_comment = True
+        self.enable_forum_assembly = True
+        self.forum_assembly_min_gain = 1.1
+    def extract(self, html="", **kwargs) -> dict:
+        base_url = kwargs.get("base_url", "")
+        self.process_math = kwargs.get("process_math", self.process_math)
+        self.preserve_math_containers = kwargs.get("preserve_math_containers", self.preserve_math_containers)
+        self.include_tables = kwargs.get("include_tables", self.include_tables)
+        self.include_images = kwargs.get("include_images", self.include_images)
+        self.enable_forum_assembly = kwargs.get("enable_forum_assembly", self.enable_forum_assembly)
+        self.fallback_min_length = kwargs.get("fallback_min_length", self.fallback_min_length)
+        html = html.replace("&nbsp;", " ").replace("&#160;", " ")
+        tree = load_html(html)
+        if tree is None:
+            raise ValueError
+        title = TitleParser().process(tree)
+        raw_tree = deepcopy(tree)
+        # base_url
+        base_href = tree.xpath("//base/@href")
+        if base_href and "http" in base_href[0]:
+            base_url = base_href[0]
+        self.generate_unique_id(tree)
+        # 标签转换
+        format_tree = self.convert_tags(tree, base_url=base_url)
+        format_tree = self._remove_tables_from_tree(format_tree)
+        format_tree = self._remove_images_from_tree(format_tree)
+        normal_tree = self.clean_tags(format_tree)
+        normal_tree = self._remove_tables_from_tree(normal_tree)
+        normal_tree = self._remove_images_from_tree(normal_tree)
+        fallback_tree = deepcopy(normal_tree)
+        # 主体提取
+        subtree, xp_num, drop_list = self.xp_1_5(normal_tree)
+        if xp_num == "others":
+            subtree, drop_list = self.prune_unwanted_sections(normal_tree)
+        body_html = self.get_content_html(subtree, xp_num, base_url)
+        # 论坛帖子拼装
+        forum_assembled = False
+        if self.enable_forum_assembly:
+            if xp_num != "others":
+                normal_tree, _ = self.prune_unwanted_sections(normal_tree)
+            original_length = self._text_length_from_html(body_html)
+            assembled_html = self._try_forum_assembly(normal_tree, body_html)
+            assembled_length = self._text_length_from_html(assembled_html)
+            if assembled_length >= original_length * self.forum_assembly_min_gain:
+                body_html = assembled_html
+                forum_assembled = True
+        # 条件兜底
+        current_length = self._text_length_from_html(body_html)
+        fallback_strategy = "primary"
+        if current_length < self.fallback_min_length:
+            body_html, fallback_strategy = self.apply_fallbacks(
+                primary_html=body_html,
+                base_url=base_url,
+                normal_tree=fallback_tree,
+                raw_tree=raw_tree,
+            )
+        body_html = self._strip_tables_from_html(body_html)
+        body_html = self._strip_images_from_html(body_html)
+        text_length = self._text_length_from_html(body_html)
+        return {
+            "xp_num": xp_num,
+            "drop_list": drop_list,
+            "html": body_html,
+            "title": title,
+            "base_url": base_url,
+            "fallback_strategy": fallback_strategy,
+            "text_length": text_length,
+            "forum_assembled": forum_assembled,
+        }
+    def _try_forum_assembly(self, normal_tree, body_html):
+        if not body_html:
+            return body_html
+        try:
+            body_html_tree = fromstring(body_html)
+        except Exception:
+            return body_html
+        try:
+            body_tree = body_html_tree.body
+        except:
+            body_tree = Element("body")
+            body_tree.extend(body_html_tree)
+        main_ids = body_tree.xpath(f".//@{Unique_ID}")
+        for main_id in main_ids:
+            main_tree = normal_tree.xpath(f".//*[@{Unique_ID}={main_id}]")
+            if main_tree:
+                try:
+                    self.remove_node(main_tree[0])
+                except:
+                    pass
+        if not main_ids:
+            main_ids = [-1]
+        for c_xpath in Forum_XPATH:
+            while True:
+                matches = normal_tree.xpath(c_xpath)
+                if not matches:
+                    break
+                x = matches[0]
+                self.remove_node(x)
+                if "'post-'" in c_xpath or "'post_'" in c_xpath:
+                    elem_id = x.attrib.get("id", "").lower()
+                    if not (re.search(r'post-\d+', elem_id) or re.search(r'post_\d+', elem_id)):
+                        continue
+                if "header" in x.attrib.get("class", "").lower() or "header" in x.attrib.get("id", "").lower():
+                    continue
+                try:
+                    node_id = int(x.attrib.get(Unique_ID, "0"))
+                    last_main_id = int(main_ids[-1]) if main_ids else -1
+                    if node_id > last_main_id:
+                        body_tree.append(x)
+                    else:
+                        prefix_div = Element("div")
+                        suffix_div = Element("div")
+                        need_prefix = False
+                        need_suffix = False
+                        while x.xpath(f".//*[number(@{Unique_ID}) > {last_main_id}]"):
+                            tmp_x = x.xpath(f".//*[number(@{Unique_ID}) > {last_main_id}]")[0]
+                            self.remove_node(tmp_x)
+                            suffix_div.append(tmp_x)
+                            need_suffix = True
+                        while x.xpath(f".//*[number(@{Unique_ID}) < {last_main_id}]"):
+                            tmp_x = x.xpath(f".//*[number(@{Unique_ID}) < {last_main_id}]")[0]
+                            self.remove_node(tmp_x)
+                            prefix_div.append(tmp_x)
+                            need_prefix = True
+                        if need_prefix:
+                            body_tree.insert(0, prefix_div)
+                        if need_suffix:
+                            body_tree.append(suffix_div)
+                except Exception:
+                    pass
+        result_html = re.sub(
+            f' {Unique_ID}="\d+"',
+            "",
+            tostring(body_tree, encoding=str),
+        )
+        return result_html

ultradata_math_parser/readability_plus.py ADDED Viewed

	@@ -0,0 +1,539 @@

+# -*- coding:utf-8 -*-
+from lxml.etree import tounicode
+from lxml.html import document_fromstring, fragment_fromstring
+from ultradata_math_parser.utils import *
+def to_int(x):
+    if not x:
+        return None
+    x = x.strip()
+    if x.endswith("px"):
+        return int(x[:-2])
+    if x.endswith("em"):
+        return int(x[:-2]) * 12
+    return int(x)
+def clean(text):
+    text = re.sub(r"\s{255,}", " " * 255, text)
+    text = re.sub(r"\s*\n\s*", "\n", text)
+    text = re.sub(r"\t|[ \t]{2,}", " ", text)
+    return text.strip()
+def text_length(i):
+    return len(clean(i.text_content() or ""))
+bad_attrs = ["width", "height", "style", "[-a-z]*color", "background[-a-z]*", "on*"]
+single_quoted = "'[^']+'"
+double_quoted = '"[^"]+"'
+non_space = "[^ \"'>]+"
+htmlstrip = re.compile(
+    "<"  # open
+    "([^>]+) "  # prefix
+    "(?:%s) *" % ("|".join(bad_attrs),)
+    + "= *(?:%s|%s|%s)"  # undesirable attributes
+    % (non_space, single_quoted, double_quoted)
+    + "([^>]*)"  # value  # postfix
+      ">",  # end
+    re.I,
+)
+def clean_attributes(html):
+    while htmlstrip.search(html):
+        html = htmlstrip.sub("<\\1\\2>", html)
+    return html
+class Document:
+    def __init__(
+            self,
+            input,
+            url=None,
+            min_text_length=25,
+            retry_length=250,
+            xpath=False,
+            handle_failures="discard",
+            xp_num="others",
+            need_comment=False,
+    ):
+        self.input = input
+        self.html = None
+        self.encoding = None
+        self.positive_keywords = None
+        self.negative_keywords = None
+        self.url = url
+        self.min_text_length = min_text_length
+        self.retry_length = retry_length
+        self.xpath = xpath
+        self.handle_failures = handle_failures
+        self.xp_num = xp_num
+        self.need_comment = need_comment
+        if not need_comment:
+            self.REGEXES = {
+                "unlikelyCandidatesRe": re.compile(
+                    r"combx|comment|community|disqus|extra|foot|header|menu|remark|rss|shoutbox|sidebar|sponsor|ad-break|agegate|pagination|pager|popup|tweet|twitter",
+                    re.I,
+                ),
+                "okMaybeItsACandidateRe": re.compile(
+                    r"and|article|body|column|main|shadow", re.I
+                ),
+                "positiveRe": re.compile(
+                    r"article|body|content|entry|hentry|main|page|pagination|post|text|blog|story",
+                    re.I,
+                ),
+                "negativeRe": re.compile(
+                    r"combx|comment|com-|contact|foot|footer|footnote|masthead|media|meta|outbrain|promo|related|scroll|shoutbox|sidebar|sponsor|shopping|tags|tool|widget",
+                    re.I,
+                ),
+                "divToPElementsRe": re.compile(
+                    r"<(a|blockquote|dl|div|img|ol|p|pre|table|ul)", re.I
+                ),
+                "videoRe": re.compile(r"https?:\/\/(www\.)?(youtube|vimeo)\.com", re.I),
+            }
+        else:
+            self.REGEXES = {
+                "unlikelyCandidatesRe": re.compile(
+                    r"combx|community|disqus|extra|foot|header|menu|remark|rss|shoutbox|sidebar|sponsor|ad-break|agegate|pagination|pager|popup|tweet|twitter",
+                    re.I,
+                ),
+                "okMaybeItsACandidateRe": re.compile(
+                    r"and|article|body|column|main|shadow", re.I
+                ),
+                "positiveRe": re.compile(
+                    r"article|body|content|entry|hentry|main|page|pagination|post|text|blog|story",
+                    re.I,
+                ),
+                "negativeRe": re.compile(
+                    r"combx|com-|contact|foot|footer|footnote|masthead|media|meta|outbrain|promo|related|scroll|shoutbox|sidebar|sponsor|shopping|tags|tool|widget",
+                    re.I,
+                ),
+                "divToPElementsRe": re.compile(
+                    r"<(a|blockquote|dl|div|img|ol|p|pre|table|ul)", re.I
+                ),
+                "videoRe": re.compile(r"https?:\/\/(www\.)?(youtube|vimeo)\.com", re.I),
+            }
+    def _html(self, force=False):
+        if force or self.html is None:
+            self.html = self._parse(self.input)
+            if self.xpath:
+                root = self.html.getroottree()
+                for i in self.html.getiterator():
+                    i.attrib["x"] = root.getpath(i)
+        return self.html
+    def _parse(self, input: HtmlElement):
+        doc = input
+        base_href = self.url
+        if base_href:
+            try:
+                doc.make_links_absolute(
+                    base_href,
+                    resolve_base_href=True,
+                    handle_failures=self.handle_failures,
+                )
+            except TypeError:
+                doc.make_links_absolute(
+                    base_href,
+                    resolve_base_href=True,
+                    handle_failures=self.handle_failures,
+                )
+        else:
+            doc.resolve_base_href(handle_failures=self.handle_failures)
+        return doc
+    def summary(self, html_partial=False):
+        try:
+            ruthless = True
+            while True:
+                self._html(True)
+                for i in self.tags(self.html, "body"):
+                    i.set("id", "readabilityplusBody")
+                if ruthless and self.xp_num == "others":
+                    self.remove_unlikely_candidates()
+                self.transform_misused_divs_into_paragraphs()
+                if self.xp_num == "others":
+                    candidates = self.score_paragraphs()
+                    best_candidate = self.select_best_candidate(candidates)
+                else:
+                    best_candidate = None
+                    ruthless = False
+                    candidates = {}
+                if best_candidate:
+                    article = self.get_article(
+                        candidates, best_candidate, html_partial=html_partial
+                    )
+                else:
+                    if ruthless:
+                        ruthless = False
+                        continue
+                    else:
+                        article = self.html.find("body")
+                        if article is None:
+                            article = self.html
+                cleaned_article = self.sanitize(article, candidates)
+                article_length = len(cleaned_article or "")
+                retry_length = self.retry_length
+                of_acceptable_length = article_length >= retry_length
+                if ruthless and not of_acceptable_length:
+                    ruthless = False
+                    continue
+                else:
+                    return cleaned_article
+        except Exception as e:
+            return None
+    def get_article(self, candidates, best_candidate, html_partial=False):
+        sibling_score_threshold = max([10, best_candidate["content_score"] * 0.2])
+        if html_partial:
+            output = fragment_fromstring("<div/>")
+        else:
+            output = document_fromstring("<div/>")
+        best_elem = best_candidate["elem"]
+        parent = best_elem.getparent()
+        siblings = parent.getchildren() if parent is not None else [best_elem]
+        for sibling in siblings:
+            append = False
+            if sibling is best_elem:
+                append = True
+            sibling_key = sibling
+            if (
+                    sibling_key in candidates
+                    and candidates[sibling_key]["content_score"] >= sibling_score_threshold
+            ):
+                append = True
+            if sibling.tag == "p":
+                link_density = self.get_link_density(sibling)
+                node_content = sibling.text or ""
+                node_length = len(node_content)
+                if node_length > 80 and link_density < 0.25:
+                    append = True
+                elif (
+                        node_length <= 80
+                        and link_density == 0
+                        and re.search(r"\.( |$)", node_content)
+                ):
+                    append = True
+            if append:
+                if html_partial:
+                    output.append(sibling)
+                else:
+                    output.getchildren()[0].getchildren()[0].append(sibling)
+        return output
+    def select_best_candidate(self, candidates):
+        if not candidates:
+            return None
+        sorted_candidates = sorted(
+            candidates.values(), key=lambda x: x["content_score"], reverse=True
+        )
+        for candidate in sorted_candidates[:5]:
+            elem = candidate["elem"]
+        best_candidate = sorted_candidates[0]
+        return best_candidate
+    def get_link_density(self, elem):
+        link_length = 0
+        for i in elem.findall(".//a"):
+            link_length += text_length(i)
+        total_length = text_length(elem)
+        return float(link_length) / max(total_length, 1)
+    def score_paragraphs(self):
+        MIN_LEN = self.min_text_length
+        candidates = {}
+        ordered = []
+        for elem in self.tags(self._html(), "p", "pre", "td"):
+            parent_node = elem.getparent()
+            if parent_node is None:
+                continue
+            grand_parent_node = parent_node.getparent()
+            inner_text = clean(elem.text_content() or "")
+            inner_text_len = len(inner_text)
+            if inner_text_len < MIN_LEN:
+                continue
+            if parent_node not in candidates:
+                candidates[parent_node] = self.score_node(parent_node)
+                ordered.append(parent_node)
+            if grand_parent_node is not None and grand_parent_node not in candidates:
+                candidates[grand_parent_node] = self.score_node(grand_parent_node)
+                ordered.append(grand_parent_node)
+            content_score = 1
+            content_score += len(inner_text.split(","))
+            content_score += len(inner_text.split("，"))
+            content_score += min((inner_text_len / 100), 3)
+            candidates[parent_node]["content_score"] += content_score
+            if grand_parent_node is not None:
+                candidates[grand_parent_node]["content_score"] += content_score / 2.0
+        for elem in ordered:
+            candidate = candidates[elem]
+            ld = self.get_link_density(elem)
+            score = candidate["content_score"]
+            candidate["content_score"] *= 1 - ld
+        return candidates
+    def class_weight(self, e):
+        weight = 0
+        for feature in [e.get("class", None), e.get("id", None)]:
+            if feature:
+                if self.xp_num == "others":
+                    if self.REGEXES["negativeRe"].search(feature):
+                        weight -= 25
+                    if self.REGEXES["positiveRe"].search(feature):
+                        weight += 25
+                else:
+                    if self.REGEXES["positiveRe"].search(feature):
+                        weight += 25
+                if self.positive_keywords and self.positive_keywords.search(feature):
+                    weight += 25
+                if self.negative_keywords and self.negative_keywords.search(feature):
+                    weight -= 25
+        if self.positive_keywords and self.positive_keywords.match("tag-" + e.tag):
+            weight += 25
+        if self.negative_keywords and self.negative_keywords.match("tag-" + e.tag):
+            weight -= 25
+        return weight
+    def score_node(self, elem):
+        content_score = self.class_weight(elem)
+        name = elem.tag.lower()
+        if name in ["div", "article"]:
+            content_score += 5
+        elif name in ["pre", "td", "blockquote"]:
+            content_score += 3
+        elif name in ["address", "ol", "ul", "dl", "dd", "dt", "li", "form", "aside"]:
+            content_score -= 3
+        elif name in [
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "th",
+            "header",
+            "footer",
+            "nav",
+        ]:
+            content_score -= 5
+        return {"content_score": content_score, "elem": elem}
+    def remove_unlikely_candidates(self):
+        for elem in self.html.findall(".//*"):
+            s = "%s %s" % (elem.get("class", ""), elem.get("id", ""))
+            if len(s) < 2:
+                continue
+            if (
+                    self.REGEXES["unlikelyCandidatesRe"].search(s)
+                    and (not self.REGEXES["okMaybeItsACandidateRe"].search(s))
+                    and elem.tag not in ["html", "body"]
+            ):
+                elem.drop_tree()
+    def transform_misused_divs_into_paragraphs(self):
+        for elem in self.tags(self.html, "div"):
+            if not self.REGEXES["divToPElementsRe"].search(
+                    str(b"".join(map(tostring, list(elem))))
+            ):
+                elem.tag = "p"
+        for elem in self.tags(self.html, "div"):
+            if elem.text and elem.text.strip():
+                p = fragment_fromstring("<p/>")
+                p.text = elem.text
+                elem.text = None
+                elem.insert(0, p)
+            for pos, child in reversed(list(enumerate(elem))):
+                if child.tail and child.tail.strip():
+                    p = fragment_fromstring("<p/>")
+                    p.text = child.tail
+                    child.tail = None
+                    elem.insert(pos + 1, p)
+                if child.tag == "br":
+                    child.drop_tree()
+    def tags(self, node, *tag_names):
+        for tag_name in tag_names:
+            for e in node.findall(".//%s" % tag_name):
+                yield e
+    def reverse_tags(self, node, *tag_names):
+        for tag_name in tag_names:
+            for e in reversed(node.findall(".//%s" % tag_name)):
+                yield e
+    def sanitize(self, node, candidates):
+        MIN_LEN = self.min_text_length
+        for header in self.tags(node, "h1", "h2", "h3", "h4", "h5", "h6"):
+            if self.class_weight(header) < 0 or self.get_link_density(header) > 0.33:
+                header.drop_tree()
+        for elem in self.tags(node, "iframe"):
+            if "src" in elem.attrib and self.REGEXES["videoRe"].search(
+                    elem.attrib["src"]
+            ):
+                elem.text = "VIDEO"
+            else:
+                elem.drop_tree()
+        allowed = {}
+        # Conditionally clean <table>s, <ul>s, and <div>s
+        for el in self.reverse_tags(
+                node, "table", "ul", "div", "aside", "header", "footer", "section"
+        ):
+            if el in allowed:
+                continue
+            weight = self.class_weight(el)
+            if el in candidates:
+                content_score = candidates[el]["content_score"]
+            else:
+                content_score = 0
+            tag = el.tag
+            if weight + content_score < 0:
+                el.drop_tree()
+            elif el.text_content().count(",") + el.text_content().count("，") < 10:
+                counts = {}
+                for kind in ["p", "img", "li", "a", "embed", "input"]:
+                    counts[kind] = len(el.findall(".//%s" % kind))
+                counts["li"] -= 100
+                counts["input"] -= len(el.findall('.//input[@type="hidden"]'))
+                content_length = text_length(el)
+                link_density = self.get_link_density(el)
+                to_remove = False
+                reason = ""
+                # 修改
+                if el.tag == "div" and counts["img"] >= 1:
+                    continue
+                if counts["p"] and counts["img"] > 1 + counts["p"] * 1.3:
+                    reason = "too many images (%s)" % counts["img"]
+                    # to_remove = True
+                elif counts["li"] > counts["p"] and tag not in ("ol", "ul"):
+                    reason = "more <li>s than <p>s"
+                    # to_remove = True
+                elif counts["input"] > (counts["p"] / 3):
+                    reason = "less than 3x <p>s than <input>s"
+                    to_remove = True
+                elif content_length < MIN_LEN and counts["img"] == 0:
+                    # 代码块内容过短，导致删除
+                    if el.tag in ['code', 'pre']:
+                        continue
+                    if ancestor_node_check(el, ['code', 'pre']):
+                        continue
+                    # 保留table中的链接
+                    if el.tag in ['ul', 'div'] and ancestor_node_check(el, ['td']):
+                        continue
+                    reason = (
+                            "too short content length %s without a single image"
+                            % content_length
+                    )
+                    to_remove = True
+                elif content_length < MIN_LEN and counts["img"] > 2:
+                    reason = (
+                            "too short content length %s and too many images"
+                            % content_length
+                    )
+                    to_remove = True
+                elif weight < 25 and link_density > 0.2:
+                    if tag in ["div", "ul", "table"]:
+                        ptest = el.xpath(".//text()[not(ancestor::a)]")
+                        ptest_len = text_len("".join(ptest))
+                        if ptest_len >= MIN_LEN and link_density <= 0.3:
+                            continue
+                    if tag == "table":
+                        if len(el.xpath('.//tr[1]/td')) >=2:
+                            continue
+                    if tag == "div":
+                        if el.xpath('.//table'):
+                            continue
+                    reason = "too many links %.3f for its weight %s" % (
+                        link_density,
+                        weight,
+                    )
+                    to_remove = True
+                elif weight >= 25 and link_density > 0.5:
+                    if tag == "table":
+                        if len(el.xpath('.//tr[1]/td')) >= 2:
+                            continue
+                    if tag == "div":
+                        if el.xpath('.//table'):
+                            continue
+                    reason = "too many links %.3f for its weight %s" % (
+                        link_density,
+                        weight,
+                    )
+                    to_remove = True
+                elif (counts["embed"] == 1 and content_length < 75) or counts[
+                    "embed"
+                ] > 1:
+                    reason = (
+                        "<embed>s with too short content length, or too many <embed>s"
+                    )
+                    to_remove = True
+                elif not content_length:
+                    reason = "no content"
+                    to_remove = True
+                    i, j = 0, 0
+                    x = 1
+                    siblings = []
+                    for sib in el.itersiblings():
+                        sib_content_length = text_length(sib)
+                        if sib_content_length:
+                            i = +1
+                            siblings.append(sib_content_length)
+                            if i == x:
+                                break
+                    for sib in el.itersiblings(preceding=True):
+                        sib_content_length = text_length(sib)
+                        if sib_content_length:
+                            j = +1
+                            siblings.append(sib_content_length)
+                            if j == x:
+                                break
+                    if siblings and sum(siblings) > 1000:
+                        to_remove = False
+                        for desnode in self.tags(el, "table", "ul", "div", "section"):
+                            allowed[desnode] = True
+                if to_remove:
+                    el.drop_tree()
+                else:
+                    pass
+        self.html = node
+        return self.get_clean_html()
+    def get_clean_html(self):
+        return clean_attributes(tounicode(self.html, method="html"))

ultradata_math_parser/utils.py ADDED Viewed

	@@ -0,0 +1,499 @@

+# -*- coding:utf-8 -*-
+import os
+import re
+import logging
+import subprocess
+import tempfile
+from gzip import decompress
+import numpy as np
+from lxml import etree
+from lxml.html import Element, HtmlElement, HTMLParser, fromstring, tostring
+from lxml.html.clean import Cleaner
+from urllib3.response import HTTPResponse
+from ultradata_math_parser.config import Unique_ID
+try:
+    import brotli
+except ImportError:
+    brotli = None
+try:
+    from cchardet import detect as cchardet_detect
+except ImportError:
+    cchardet_detect = None
+from difflib import SequenceMatcher
+from charset_normalizer import from_bytes
+HTML_PARSER = HTMLParser(
+    collect_ids=False,
+    default_doctype=False,
+    encoding="utf-8",
+    remove_comments=True,
+    remove_pis=True,
+)
+DOCTYPE_TAG = re.compile("^< ?! ?DOCTYPE.+?/ ?>", re.I)
+UNICODE_ALIASES = {"utf-8", "utf_8"}
+HTML_CLEANER = Cleaner(
+    annoying_tags=False,
+    comments=True,
+    embedded=False,
+    forms=False,
+    frames=False,
+    javascript=False,
+    links=False,
+    meta=False,
+    page_structure=False,
+    processing_instructions=True,
+    remove_unknown_tags=False,
+    safe_attrs_only=False,
+    scripts=False,
+    style=False,
+)
+color_regex = re.compile(r"\\textcolor\[.*?\]\{.*?\}")
+latex_image_class_names = [
+    "latexcenter",
+    "latex",
+    "tex",
+    "latexdisplay",
+    "latexblock",
+    "latexblockcenter",
+]
+def _translator():
+    old_log_level = logging.getLogger().level
+    try:
+        import py_asciimath.translator.translator as _translator
+        return _translator
+    finally:
+        logging.getLogger().setLevel(old_log_level)
+def ASCIIMath2Tex(*args, **kwargs):
+    return _translator().ASCIIMath2Tex(*args, **kwargs)
+def MathML2Tex(*args, **kwargs):
+    return _translator().MathML2Tex(*args, **kwargs)
+asciimath2tex = ASCIIMath2Tex(log=False)
+def lcs_of_2(a, b):
+    match = SequenceMatcher(None, a, b).find_longest_match(0, len(a), 0, len(b))
+    return a[match[0]: match[0] + match[2]]
+def lcs_of_list(*args):
+    if len(args) == 2:
+        return lcs_of_2(args[0], args[1])
+    first = args[0]
+    remains = args[1:]
+    return lcs_of_2(first, lcs_of_list(*remains))
+def isutf8(data):
+    try:
+        data.decode("UTF-8")
+    except UnicodeDecodeError:
+        return False
+    return True
+def handle_compressed_file(filecontent):
+    if isinstance(filecontent, bytes):
+        if filecontent[:2] == b"\x1f\x8b":
+            try:
+                filecontent = decompress(filecontent)
+            except (EOFError, OSError):
+                pass
+        elif brotli is not None:
+            try:
+                filecontent = brotli.decompress(filecontent)
+            except brotli.error:
+                pass
+    return filecontent
+def detect_encoding(bytesobject):
+    if isutf8(bytesobject):
+        return ["utf-8"]
+    guesses = []
+    if cchardet_detect is not None:
+        cchardet_guess = cchardet_detect(bytesobject)["encoding"]
+        if cchardet_guess is not None:
+            guesses.append(cchardet_guess.lower())
+    detection_results = from_bytes(bytesobject[:15000]) or from_bytes(bytesobject)
+    if len(detection_results) > 0:
+        guesses.extend([r.encoding for r in detection_results])
+    return [g for g in guesses if g not in UNICODE_ALIASES]
+def decode_file(filecontent):
+    if isinstance(filecontent, str):
+        return filecontent
+    htmltext = None
+    filecontent = handle_compressed_file(filecontent)
+    for guessed_encoding in detect_encoding(filecontent):
+        try:
+            htmltext = filecontent.decode(guessed_encoding)
+        except (LookupError, UnicodeDecodeError):
+            htmltext = None
+        else:
+            break
+    return htmltext or str(filecontent, encoding="utf-8", errors="replace")
+def strip_faulty_doctypes(htmlstring: str, beginning: str) -> str:
+    if "doctype" in beginning:
+        firstline, _, rest = htmlstring.partition("\n")
+        return DOCTYPE_TAG.sub("", firstline, count=1) + "\n" + rest
+    return htmlstring
+def is_dubious_html(beginning: str) -> bool:
+    return "html" not in beginning
+def fromstring_bytes(htmlobject):
+    tree = None
+    try:
+        tree = fromstring(
+            htmlobject.encode("utf8", "surrogatepass"), parser=HTML_PARSER
+        )
+    except Exception as err:
+        pass
+    return tree
+def ancestor_node_check(node: HtmlElement, tags: list):
+    for tag in tags:
+        if node.xpath(f'ancestor::{tag}[1]'):
+            return True
+    return False
+def load_html(htmlobject):
+    if isinstance(htmlobject, HtmlElement):
+        return htmlobject
+    if isinstance(htmlobject, HTTPResponse) or hasattr(htmlobject, "data"):
+        htmlobject = htmlobject.data
+    if not isinstance(htmlobject, (bytes, str)):
+        raise TypeError("incompatible input type", type(htmlobject))
+    tree = None
+    htmlobject = decode_file(htmlobject)
+    beginning = htmlobject[:50].lower()
+    check_flag = is_dubious_html(beginning)
+    htmlobject = strip_faulty_doctypes(htmlobject, beginning)
+    fallback_parse = False
+    try:
+        tree = fromstring(htmlobject, parser=HTML_PARSER)
+    except ValueError:
+        tree = fromstring_bytes(htmlobject)
+        fallback_parse = True
+    except Exception as err:
+        pass
+    if (tree is None or len(tree) < 1) and not fallback_parse:
+        tree = fromstring_bytes(htmlobject)
+    if tree is not None and check_flag is True and len(tree) < 2:
+        tree = None
+    return tree
+class W3MError(RuntimeError):
+    """Raised when w3m rendering fails."""
+def run_w3m_dump(html_content: str, w3m_path: str, *, columns: int = 200) -> str:
+    """
+    Render HTML content into plain text using w3m.
+    :param html_content: HTML snippet to render.
+    :param w3m_path: Path to the w3m executable.
+    :param columns: Column width passed to w3m (-cols).
+    :return: Rendered plain text.
+    :raises RuntimeError: if w3m is unavailable or returns a non-zero exit code.
+    """
+    if not w3m_path:
+        raise W3MError("w3m path must be provided")
+    tmp_file = tempfile.NamedTemporaryFile(
+        mode="w", suffix=".html", delete=False, encoding="utf-8"
+    )
+    try:
+        tmp_file.write(html_content or "")
+        tmp_file.flush()
+        tmp_file.close()
+        try:
+            completed = subprocess.run(
+                [
+                    w3m_path,
+                    "-dump",
+                    "-T",
+                    "text/html",
+                    "-cols",
+                    str(columns),
+                    tmp_file.name,
+                ],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except FileNotFoundError as exc:
+            raise W3MError(f"w3m executable not found at '{w3m_path}'") from exc
+        except subprocess.CalledProcessError as exc:
+            stderr = (exc.stderr or "").strip()
+            message = f"w3m exited with status {exc.returncode}"
+            if stderr:
+                message = f"{message}: {stderr}"
+            raise W3MError(message) from exc
+        return completed.stdout
+    finally:
+        try:
+            os.unlink(tmp_file.name)
+        except OSError:
+            pass
+def is_empty_element(node: HtmlElement):
+    return not node.getchildren() and not node.text
+def iter_node(element: HtmlElement):
+    yield element
+    for sub_element in element:
+        if isinstance(sub_element, HtmlElement):
+            yield from iter_node(sub_element)
+def img_div_check(tree):
+    """
+    如果一个div中只有一张图，且子节点数小于4则保留
+    """
+    if len(tree.xpath(".//img")) == 1 and len(tree.xpath(".//*")) < 4:
+        return False
+    else:
+        return True
+def text_len(s):
+    s = re.sub(" +", " ", s)  # 将连续的多个空格替换为一个空格
+    s = re.sub("[\n\t\r]+", "\n", s)
+    english_words = s.split()
+    chinese_characters = re.findall(r"[\u4e00-\u9fff]", s)
+    japanese_characters = re.findall(r"[\u3040-\u309F\u30A0-\u30FF]", s)
+    arabic_characters = re.findall(r"[\u0600-\u06FF]", s)
+    return (
+            len(english_words)
+            + len(chinese_characters)
+            + len(japanese_characters)
+            + len(arabic_characters)
+    )
+def alias(element):
+    if element is None:
+        return ""
+    tag = element.tag
+    # skip nth-child
+    if tag in ["html", "body"]:
+        return tag
+    attribs = [tag]
+    for k, v in element.attrib.items():
+        if k == Unique_ID:
+            continue
+        k, v = re.sub(r"\s*", "", k), re.sub(r"\s*", "", v)
+        v = re.sub(r"-\d+", "", v)
+        attribs.append(f'[{k}="{v}"]' if v else f"[{k}]")
+    result = "".join(attribs)
+    # 直接将当前子节点属性展示上来
+    nth = ""
+    for child in element.getchildren():
+        if child.tag in ["dt", "dd", "li"]:
+            try:
+                # 子节点个数
+                nth += str(len(list(child.getchildren())))
+            except:
+                pass
+            continue
+        attribs = [child.tag]
+        for k, v in child.attrib.items():
+            if k == Unique_ID:
+                continue
+            k, v = re.sub(r"\s*", "", k), re.sub(r"\s*", "", v)
+            v = re.sub(r"-\d+", "", v)
+            attribs.append(f"[{k}]" if v else f"[{k}]")
+        nth += "".join(attribs)
+    result += f":{nth}"
+    return result
+def similarity2(s1, s2):
+    if not s1 or not s2:
+        return 0
+    s1_set = set(list(s1))
+    s2_set = set(list(s2))
+    intersection = s1_set.intersection(s2_set)
+    union = s1_set.union(s2_set)
+    return len(intersection) / len(union)
+def similarity_with_element(element1, element2):
+    alias1 = alias(element1)
+    alias2 = alias(element2)
+    return similarity2(alias1, alias2)
+def similarity_with_siblings(element, siblings):
+    scores = []
+    for sibling in siblings:
+        # TODO: maybe compare all children not only alias
+        scores.append(similarity_with_element(element, sibling))
+    if not scores:
+        return 0
+    # 去掉一个最低值
+    min_value = min(scores)
+    scores.remove(min_value)
+    return np.mean(scores)
+def number_of_a_char(ele, xpath=".//a//text()"):
+    s = "".join(ele.xpath(xpath)).strip()
+    return text_len(s)
+def number_of_char(ele, xpath=".//text()"):
+    s = "".join(ele.xpath(xpath)).strip()
+    return text_len(s) + 1
+def density_of_a_text(ele, pre=0.7):
+    a_char = number_of_a_char(ele)
+    t_char = number_of_char(ele)
+    if a_char / t_char >= pre:
+        return True
+    else:
+        return False
+def uniquify_list(l):
+    return list(dict.fromkeys(l))
+def trim(string):
+    """Remove unnecessary spaces within a text string"""
+    try:
+        return " ".join(string.split()).strip()
+    except (AttributeError, TypeError):
+        return None
+def collect_link_info(links_xpath, favor_precision=False):
+    shortelems, mylist = 0, []
+    threshold = 10 if not favor_precision else 50
+    for subelem in links_xpath:
+        subelemtext = trim(subelem.text_content())
+        if subelemtext:
+            mylist.append(subelemtext)
+            if len(subelemtext) < threshold:
+                shortelems += 1
+    lengths = sum(len(text) for text in mylist)
+    return lengths, len(mylist), shortelems, mylist
+def link_density_test(element, text, favor_precision=False):
+    links_xpath, mylist = element.findall(".//a"), []
+    if links_xpath:
+        if element.tag == "p":
+            if favor_precision is False:
+                if element.getnext() is None:
+                    limitlen, threshold = 60, 0.8
+                else:
+                    limitlen, threshold = 30, 0.8
+            else:
+                limitlen, threshold = 200, 0.8
+        else:
+            if element.getnext() is None:
+                limitlen, threshold = 300, 0.8
+            else:
+                limitlen, threshold = 100, 0.8
+        elemlen = len(text)
+        if elemlen < limitlen:
+            linklen, elemnum, shortelems, mylist = collect_link_info(
+                links_xpath, favor_precision
+            )
+            if elemnum == 0:
+                return True, mylist
+            if density_of_a_text(element, 0.5):
+                if linklen > threshold * elemlen or (
+                        elemnum > 1 and shortelems / elemnum > 0.8
+                ):
+                    return True, mylist
+    return False, mylist
+def text_strip(text):
+    return text.strip() if text else text
+def wrap_math(s, display=False):
+    s = re.sub(r"\s+", " ", s)
+    s = color_regex.sub("", s)
+    s = s.replace("$", "")
+    s = s.replace("\n", " ").replace("\\n", "")
+    s = s.strip()
+    if len(s) == 0:
+        return s
+    # Don't wrap if it's already in \align
+    if "align" in s:
+        return s
+    if display:
+        return "$$" + s + "$$"
+    return "$" + s + "$"
+def extract_asciimath(s):
+    parsed = asciimath2tex.translate(s)
+    return parsed
+cur_file = os.path.abspath(__file__)
+xsl_path = os.path.join(os.path.dirname(cur_file), "mmltex/mmltex.xsl")
+xslt = etree.parse(xsl_path)
+transform = etree.XSLT(xslt)
+def mml_to_latex(mml_code):
+    # Remove any attibutes from the math tag
+    mml_code = re.sub(r"(<math.*?>)", r"\1", mml_code)
+    mml_ns = mml_code.replace(
+        "<math>", '<math xmlns="http://www.w3.org/1998/Math/MathML">'
+    )  # Required.
+    mml_ns = mml_ns.replace("&quot;", '"')
+    mml_ns = mml_ns.replace("'\\\"", '"').replace("\\\"'", '"')
+    # 很多网页中标签内容就是错误
+    # pattern = r"(<[^<>]*?\s)(mathbackground|mathsize|mathvariant|mathfamily|class|separators|style|id|rowalign|columnspacing|rowlines|columnlines|frame|framespacing|equalrows|equalcolumns|align|linethickness|lspace|rspace|mathcolor|rowspacing|displaystyle|style|columnalign|open|close|right|left)(?=\s|>)(?![\"'][^<>]*?>)"
+    pattern = r'"([^"]+?)\''
+    mml_ns = re.sub(pattern, r'"\1"', mml_ns)
+    mml_dom = etree.fromstring(mml_ns)
+    mmldom = transform(mml_dom)
+    latex_code = str(mmldom)
+    return latex_code