md2bbcode 0.1.0__py2.py3-none-any.whl

md2bbcode/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

md2bbcode/eqlog.md

@@ -0,0 +1,36 @@
+# EQLogParser
+Everquest Log Parser for Live/TLP servers with basic support for P99.
+
+Link to DOWNLOAD the latest Installer:</br>
+https://github.com/kauffman12/EQLogParser/raw/master/Release/EQLogParser-install-2.2.48.exe
+
+Minimum Requirements:
+1. Windows 10 x64
+2. .Net 8.0 Desktop Runtime for x64
+
+.Net 8.0 is provided by Microsoft but is not included with Windows. It can be downloaded from here:</br>
+https://dotnet.microsoft.com/en-us/download/dotnet/thank-you/runtime-desktop-8.0.7-windows-x64-installer
+
+If Everquest is in windowed mode but the Damage Meter or other overlays are hidden when you switch to the game make sure Overlap with Taskbar is turned off:</br>
+
+![Parser](./examples/eqsetting.png)
+
+Note for Developers:</br>
+Syncfusion components used by this application require a license. If you apply for a community license you should be able to get one for free.
+
+Additional Notes:</br>
+The installer for EQLogParser has been signed with a certificate. It's recommended that the following steps are done ONCE so that you're sure you have an official version. After your system trusts the certificate you'll notice the install prompt will be blue in color and no longer say Unknown Publisher. Then in the future if it returns to yellow/Unknown Publisher you'll know that the installer either wasn't from me or I had to change certificates. Which I will mention here if I have change them. Note that this is not required and if you don't bother installing the certs everything should still work fine.
+
+1. right-click the exe file and choose properties
+2. under the digital signatures tab select the one signature and click details
+3. click View Certificate
+4. click Install Certificate
+
+Lastly, EQLogParser-2.2.13.msi in the Releases folder can be ignored by most people. It exists to allow auto update to work from old versions of the parser. Old parsers were hard coded to look for MSI files and this one just wraps the exe installer for 2.2.13. Then the next time the parser is started it will auto update to the latest exe installer.
+
+
+# Example
+![Parser](./examples/example1.png)
+
+# Damage Meter and Timer Overlay Example
+![Damage Meter](./examples/example2.png)

md2bbcode/html2bbcode.py

@@ -0,0 +1,143 @@
+# converts some HTML tags to BBCode
+# pass --debug to save the output to readme.finalpass
+# may be better off replacing this with html to markdown (and then to bbcode). Lepture recommeds a JS html to markdown converter: sundown
+from bs4 import BeautifulSoup
+import argparse
+
+def handle_font_tag(tag, replacements):
+    """Handles the conversion of <font> tag with attributes like color and size."""
+    attributes = []
+    if 'color' in tag.attrs:
+        attributes.append(f"COLOR={tag['color']}")
+    if 'size' in tag.attrs:
+        attributes.append(f"SIZE={tag['size']}")
+    if 'face' in tag.attrs:
+        attributes.append(f"FONT={tag['face']}")
+
+    inner_content = ''.join(recursive_html_to_bbcode(child, replacements) for child in tag.children)
+    if attributes:
+        # Nest all attributes. Example: [COLOR=red][SIZE=5]content[/SIZE][/COLOR]
+        for attr in reversed(attributes):
+            inner_content = f"[{attr}]{inner_content}[/{attr.split('=')[0]}]"
+    return inner_content
+
+def handle_style_tag(tag, replacements):
+    """Handles the conversion of tags with style attributes like color, size, and font."""
+    attributes = []
+    style = tag.attrs.get('style', '')
+
+    # Extracting CSS properties
+    css_properties = {item.split(':')[0].strip(): item.split(':')[1].strip() for item in style.split(';') if ':' in item}
+
+    # Mapping CSS properties to BBCode
+    if 'color' in css_properties:
+        attributes.append(f"COLOR={css_properties['color']}")
+    if 'font-size' in css_properties:
+        attributes.append(f"SIZE={css_properties['font-size']}")
+    if 'font-family' in css_properties:
+        attributes.append(f"FONT={css_properties['font-family']}")
+    if 'text-decoration' in css_properties and 'line-through' in css_properties['text-decoration']:
+        attributes.append("S")  # Assume strike-through
+    if 'text-decoration' in css_properties and 'underline' in css_properties['text-decoration']:
+        attributes.append("U")
+    if 'font-weight' in css_properties:
+        if css_properties['font-weight'].lower() == 'bold' or (css_properties['font-weight'].isdigit() and int(css_properties['font-weight']) >= 700):
+            attributes.append("B")  # Assume bold
+
+    inner_content = ''.join(recursive_html_to_bbcode(child, replacements) for child in tag.children)
+    if attributes:
+        # Nest all attributes
+        for attr in reversed(attributes):
+            if '=' in attr:  # For attributes with values
+                inner_content = f"[{attr}]{inner_content}[/{attr.split('=')[0]}]"
+            else:  # For simple BBCode tags like [B], [I], [U], [S]
+                inner_content = f"[{attr}]{inner_content}[/{attr}]"
+    return inner_content
+
+def recursive_html_to_bbcode(tag, replacements):
+    """Recursively convert HTML content of a given tag to BBCode."""
+    if tag.name is None:
+        return str(tag)
+    elif tag.name == 'br':
+        # Directly return a newline for <br> or </br> tags
+        return '\n'
+    elif tag.name in replacements:
+        bb_tag = replacements[tag.name]
+        inner_content = ''
+        for child in tag.children:
+            inner_content += recursive_html_to_bbcode(child, replacements)
+        
+        if tag.name in ['a', 'img']:
+            if tag.name == 'a':
+                href = tag.get('href', '')
+                return f"[URL={href}]{inner_content}[/URL]"
+            elif tag.name == 'img':
+                src = tag.get('src', '')
+                alt = tag.get('alt', '')
+                if alt:
+                    return f"[IMG alt=\"{alt}\"]{src}[/IMG]"
+                else:
+                    return f"[IMG]{src}[/IMG]"
+        elif tag.name in ['ul', 'ol']:
+            return f"[{bb_tag}]{inner_content}[/LIST]"
+        elif tag.name == 'font':
+            # Special handling for <font> tag with attributes
+            return handle_font_tag(tag, replacements)  # Pass replacements here
+        elif tag.name == 'li':
+            return f"[*]{inner_content}"
+        else:
+            return f"[{bb_tag}]{inner_content}[/{bb_tag}]"
+    elif tag.name in ['span', 'div']:
+        return handle_style_tag(tag, replacements)
+    else:
+        # For tags not in the replacements, concatenate the content
+        return ''.join(recursive_html_to_bbcode(child, replacements) for child in tag.children)
+
+def html_to_bbcode(html):
+    replacements = {
+        'b': 'B',
+        'strong': 'B',
+        'i': 'I',
+        'em': 'I',
+        'u': 'U',
+        's': 'S',
+        'sub': 'SUB',
+        'sup': 'SUP',
+        'p': '',  # Handled by default
+        'ul': 'LIST',
+        'ol': 'LIST=1',
+        'li': '*',  # Special handling in recursive function
+        'font': '',  # To be handled for attributes
+        'blockquote': 'QUOTE',
+        'pre': 'CODE',
+        'code': 'ICODE',
+        'a': 'URL',  # Special handling for attributes
+        'img': 'IMG'  # Special handling for attributes
+    }
+
+    soup = BeautifulSoup(html, 'html.parser')
+    return recursive_html_to_bbcode(soup, replacements)
+
+def process_html(input_html, debug=False, output_file=None):
+    converted_bbcode = html_to_bbcode(input_html)
+
+    if debug:
+        with open(output_file, 'w', encoding='utf-8') as file:
+            file.write(converted_bbcode)
+    else:
+        return converted_bbcode
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Convert HTML to BBCode with optional debugging output.")
+    parser.add_argument('input_file', type=str, help='Input HTML file path')
+    parser.add_argument('--debug', action='store_true', help='Save output to readme.finalpass for debugging')
+    
+    args = parser.parse_args()
+    input_file = args.input_file
+    output_file = 'readme.finalpass' if args.debug else None
+
+    with open(input_file, 'r', encoding='utf-8') as file:
+        html_content = file.read()
+
+    # Call the processing function
+    process_html(html_content, debug=args.debug, output_file=output_file)

md2bbcode/main.py

@@ -0,0 +1,66 @@
+# uses a custom mistune renderer to convert Markdown to BBCode. The custom renderer is defined in the bbcode.py file.
+# pass --debug to save the output to readme.1stpass (main.py) and readme.finalpass (html2bbcode)
+# for further debugging, you can convert the markdown file to AST using md2ast.py. Remember to load the plugin(s) you want to test.
+
+#standard library
+import argparse
+import sys
+
+# mistune
+import mistune
+from mistune.plugins.formatting import strikethrough, mark, superscript, subscript, insert
+from mistune.plugins.table import table, table_in_list
+from mistune.plugins.footnotes import footnotes
+from mistune.plugins.task_lists import task_lists
+from mistune.plugins.def_list import def_list
+from mistune.plugins.abbr import abbr
+from mistune.plugins.spoiler import spoiler
+
+# local
+from .renderers.bbcode import BBCodeRenderer
+from .html2bbcode import process_html
+
+def convert_markdown_to_bbcode(markdown_text, domain):
+    # Create a Markdown parser instance using the custom BBCode renderer
+    markdown_parser = mistune.create_markdown(renderer=BBCodeRenderer(domain=domain), plugins=[strikethrough, mark, superscript, subscript, insert, table, footnotes, task_lists, def_list, abbr, spoiler, table_in_list])
+
+    # Convert Markdown text to BBCode
+    return markdown_parser(markdown_text)
+
+def process_readme(markdown_text, domain, debug=False):
+    # Convert Markdown to BBCode
+    bbcode_text = convert_markdown_to_bbcode(markdown_text, domain)
+
+    # If debug mode, save intermediate BBCode
+    if debug:
+        with open('readme.1stpass', 'w', encoding='utf-8') as file:
+            file.write(bbcode_text)
+
+    # Convert BBCode formatted as HTML to final BBCode
+    final_bbcode = process_html(bbcode_text, debug, 'readme.finalpass')
+
+    return final_bbcode
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert Markdown file to BBCode with HTML processing.')
+    parser.add_argument('input', help='Input Markdown file path')
+    parser.add_argument('--domain', help='Domain to prepend to relative URLs')
+    parser.add_argument('--debug', action='store_true', help='Output intermediate results to files for debugging')
+    args = parser.parse_args()
+
+    if args.input == '-':
+        # Read Markdown content from stdin
+        markdown_text = sys.stdin.read()
+    else:
+        with open(args.input, 'r', encoding='utf-8') as md_file:
+            markdown_text = md_file.read()
+
+    # Process the readme and get the final BBCode
+    final_bbcode = process_readme(markdown_text, args.domain, args.debug)
+
+    # Optionally, print final BBCode to console
+    if not args.debug:
+        print(final_bbcode)
+
+if __name__ == '__main__':
+    main()

md2bbcode/md2ast.py

@@ -0,0 +1,44 @@
+# this is for debugging the custom mistune renderer bbcode.py
+import argparse
+import mistune
+import json  # Import the json module for serialization
+from mistune.plugins.formatting import strikethrough, mark, superscript, subscript, insert
+from mistune.plugins.table import table, table_in_list
+from mistune.plugins.footnotes import footnotes
+from mistune.plugins.task_lists import task_lists
+from mistune.plugins.def_list import def_list
+from mistune.plugins.abbr import abbr
+from mistune.plugins.spoiler import spoiler
+
+def convert_markdown_to_ast(input_filepath, output_filepath):
+    # Initialize Markdown parser with no renderer to produce an AST
+    markdown_parser = mistune.create_markdown(renderer=None, plugins=[strikethrough, mark, superscript, subscript, insert, table, footnotes, task_lists, def_list, abbr, spoiler, table_in_list])
+    
+    # Read the input Markdown file
+    with open(input_filepath, 'r', encoding='utf-8') as md_file:
+        markdown_text = md_file.read()
+    
+    # Convert Markdown text to AST
+    ast_text = markdown_parser(markdown_text)
+    
+    # Serialize the AST to a JSON string
+    ast_json = json.dumps(ast_text, indent=4)
+    
+    # Write the output AST to a new file in JSON format
+    with open(output_filepath, 'w', encoding='utf-8') as ast_file:
+        ast_file.write(ast_json)
+
+def main():
+    # Create argument parser
+    parser = argparse.ArgumentParser(description='Convert Markdown file to AST file (JSON format).')
+    # Add arguments
+    parser.add_argument('input', help='Input Markdown file path')
+    parser.add_argument('output', help='Output AST file path (JSON format)')
+    # Parse arguments
+    args = parser.parse_args()
+    
+    # Convert the Markdown to AST using the provided paths
+    convert_markdown_to_ast(args.input, args.output)
+
+if __name__ == '__main__':
+    main()

md2bbcode/renderers/bbcode.py

@@ -0,0 +1,222 @@
+from mistune.core import BaseRenderer
+from mistune.util import escape as escape_text, striptags, safe_entity
+from urllib.parse import urljoin, urlparse
+
+
+class BBCodeRenderer(BaseRenderer):
+    """A renderer for converting Markdown to BBCode."""
+    _escape: bool
+    NAME = 'bbcode'
+
+    def __init__(self, escape=False, domain=None):
+        super(BBCodeRenderer, self).__init__()
+        self._escape = escape
+        self.domain = domain
+
+    def render_token(self, token, state):
+        func = self._get_method(token['type'])
+        attrs = token.get('attrs')
+
+        if 'raw' in token:
+            text = token['raw']
+        elif 'children' in token:
+            text = self.render_tokens(token['children'], state)
+        else:
+            if attrs:
+                return func(**attrs)
+            else:
+                return func()
+        if attrs:
+            return func(text, **attrs)
+        else:
+            return func(text)
+
+    def safe_url(self, url: str) -> str:
+        # Simple URL sanitization
+        if url.startswith(('javascript:', 'vbscript:', 'data:')):
+            return '#harmful-link'
+        # Check if the URL is absolute by looking for a netloc part in the URL
+        if not urlparse(url).netloc:
+            url = urljoin(self.domain, url)
+        return url
+
+    def text(self, text: str) -> str:
+        if self._escape:
+            return escape_text(text)
+        return text
+
+    def emphasis(self, text: str) -> str:
+        return '[i]' + text + '[/i]'
+
+    def strong(self, text: str) -> str:
+        return '[b]' + text + '[/b]'
+
+    def link(self, text: str, url: str, title=None) -> str:
+        return '[url=' + self.safe_url(url) + ']' + text + '[/url]'
+
+    def image(self, text: str, url: str, title=None) -> str:
+        alt_text = f' alt="{text}"' if text else ''
+        return f'[img{alt_text}]' + self.safe_url(url) + '[/img]'
+
+    def codespan(self, text: str) -> str:
+        return '[icode]' + text + '[/icode]'
+
+    def linebreak(self) -> str:
+        return '\n'
+
+    def softbreak(self) -> str:
+        return ''
+
+    def inline_html(self, html: str) -> str:
+        if self._escape:
+            return escape_text(html)
+        return html
+
+    def paragraph(self, text: str) -> str:
+        return text + '\n\n'
+
+    def heading(self, text: str, level: int, **attrs) -> str:
+        if 1 <= level <= 3:
+            return f"[HEADING={level}]{text}[/HEADING]\n"
+        else:
+            # Handle cases where level is outside 1-3
+            return f"[HEADING=3]{text}[/HEADING]\n"
+    
+    def blank_line(self) -> str:
+        return ''
+    
+    def thematic_break(self) -> str:
+        return '[hr][/hr]\n'
+    
+    def block_text(self, text: str) -> str:
+        return text
+    
+    def block_code(self, code: str, **attrs) -> str:
+        # Renders blocks of code using the language specified in Markdown
+        special_cases = {
+            'plaintext': None  # Default [CODE]
+        }
+
+        if 'info' in attrs:
+            lang_info = safe_entity(attrs['info'].strip())
+            lang = lang_info.split(None, 1)[0].lower()
+            # Check if the language needs special handling
+            bbcode_lang = special_cases.get(lang, lang)  # Use the special case if it exists, otherwise use lang as is
+            if bbcode_lang:
+                return f"[CODE={bbcode_lang}]{escape_text(code)}[/CODE]\n\n"
+            else:
+                return f"[CODE]{escape_text(code)}[/CODE]\n\n"
+        else:
+            # No language specified, render with a generic [CODE] tag
+            return f"[CODE]{escape_text(code)}[/CODE]\n\n"
+
+    def block_quote(self, text: str) -> str:
+        return '[QUOTE]\n' + text + '[/QUOTE]\n'
+
+    def block_html(self, html: str) -> str:
+        if self._escape:
+            return '<p>' + escape_text(html.strip()) + '</p>\n'
+        return html + '\n'
+
+    def block_error(self, text: str) -> str:
+        return '[color=red][icode]' + text + '[/icode][/color]\n'
+
+    def list(self, text: str, ordered: bool, **attrs) -> str:
+        tag = 'list' if not ordered else 'list=1'
+        return '[{}]'.format(tag) + text + '[/list]\n'
+
+    def list_item(self, text: str) -> str:
+        return '[*]' + text + '\n'
+    
+    def strikethrough(self, text: str) -> str:
+        return '[s]' + text + '[/s]'
+    
+    def mark(self, text: str) -> str:
+        # Simulate the mark effect with a background color in BBCode
+        return '[mark]' + text + '[/mark]'
+
+    def insert(self, text: str) -> str:
+        # Use underline to represent insertion
+        return '[u]' + text + '[/u]'
+
+    def superscript(self, text: str) -> str:
+        return '[sup]' + text + '[/sup]'
+
+    def subscript(self, text: str) -> str:
+        return '[sub]' + text + '[/sub]'
+    
+    def inline_spoiler(self, text: str) -> str:
+        return '[ISPOILER]' + text + '[/ISPOILER]'
+
+    def block_spoiler(self, text: str) -> str:
+        return '[SPOILER]\n' + text + '\n[/SPOILER]'
+
+    def footnote_ref(self, key: str, index: int):
+        # Use superscript for the footnote reference
+        return f'[sup][u][JUMPTO=fn-{index}]{index}[/JUMPTO][/u][/sup]'
+
+    def footnotes(self, text: str):
+        # Optionally wrap all footnotes in a specific section if needed
+        return '[b]Footnotes:[/b]\n' + text
+
+    def footnote_item(self, text: str, key: str, index: int):
+        # Define the footnote with an anchor at the end of the document
+        return f'[ANAME=fn-{index}]{index}[/ANAME]. {text}'
+    
+    def table(self, children, **attrs):
+        # Starting with a full-width table by default if not specified
+        # width = attrs.get('width', '100%') # comment out until XF 2.3
+        # return f'[TABLE width="{width}"]\n' + children + '[/TABLE]\n' # comment out until XF 2.3
+        return '[TABLE]\n' + children + '[/TABLE]\n'
+
+    def table_head(self, children, **attrs):
+        return '[TR]\n' + children + '[/TR]\n'
+
+    def table_body(self, children, **attrs):
+        return children
+
+    def table_row(self, children, **attrs):
+        return '[TR]\n' + children + '[/TR]\n'
+
+    def table_cell(self, text, align=None, head=False, **attrs):
+        # BBCode does not support direct cell alignment,
+        # use [LEFT], [CENTER], or [RIGHT] tags
+
+        # Use th for header cells and td for normal cells
+        tag = 'TH' if head else 'TD'
+
+        # Initialize alignment tags
+        alignment_start = ''
+        alignment_end = ''
+
+        if align == 'center':
+            alignment_start = '[CENTER]'
+            alignment_end = '[/CENTER]'
+        elif align == 'right':
+            alignment_start = '[RIGHT]'
+            alignment_end = '[/RIGHT]'
+        elif align == 'left':
+            alignment_start = '[LEFT]'
+            alignment_end = '[/LEFT]'
+
+        return f'[{tag}]{alignment_start}{text}{alignment_end}[/{tag}]\n'
+
+    def task_list_item(self, text: str, checked: bool = False) -> str:
+        # Using emojis to represent the checkbox
+        checkbox_emoji = '🗹' if checked else '☐'
+        return checkbox_emoji + ' ' + text + '\n'
+
+    def def_list(self, text: str) -> str:
+        # No specific BBCode tag for <dl>, so we just use the plain text grouping
+        return '\n' + text + '\n'
+
+    def def_list_head(self, text: str) -> str:
+        return '[b]' + text + '[/b]' + ' ' + ':' + '\n'
+
+    def def_list_item(self, text: str) -> str:
+        return '[INDENT]' + text + '[/INDENT]\n'
+    
+    def abbr(self, text: str, title: str) -> str:
+        if title:
+            return f'[abbr={title}]{text}[/abbr]'
+        return text

md2bbcode-0.1.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.3
+Name: md2bbcode
+Version: 0.1.0
+Summary: Convert Markdown to BBCode using a custom Mistune renderer.
+Project-URL: Homepage, https://github.com/RedGuides/md2bbcode
+Project-URL: Repository, https://github.com/RedGuides/md2bbcode.git
+Project-URL: Issues, https://github.com/RedGuides/md2bbcode/issues
+Project-URL: Documentation, https://github.com/RedGuides/md2bbcode#readme
+Author-email: Redbot <ask@redguides.com>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE.txt
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Utilities
+Requires-Dist: beautifulsoup4
+Requires-Dist: mistune>=3.0.2
+Description-Content-Type: text/markdown
+
+![md2bbcode logo](https://www.redguides.com/images/md2bbcode-logo.png)
+
+# md2bbcode
+**A wrapper and plugin for [Mistune](https://github.com/lepture/mistune).** It converts GitHub-flavored Markdown to Xenforo-flavored BBCode. Custom BBCodes made for RedGuides are included in `bb_codes.xml`.
+
+## Installation
+
+You can install md2bbcode using pip:
+
+```bash
+pip install md2bbcode
+```
+
+## Usage
+
+After installation, you can use md2bbcode from the command line:
+
+```bash
+md2bbcode README.md
+```
+
+If the markdown includes relative images or other assets, you can use the --domain flag to prepend a domain to the relative URLs:
+
+```bash
+md2bbcode README.md --domain https://raw.githubusercontent.com/RedGuides/md2bbcode/main/
+```
+
+### Debug Mode
+
+You can use the `--debug` flag to save intermediate results to files for debugging:
+
+```bash
+md2bbcode README.md --debug
+```
+
+## Development
+
+If you want to contribute to md2bbcode or set up a development environment, follow these steps:
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/RedGuides/md2bbcode.git
+   cd md2bbcode
+   ```
+
+2. Install Hatch, which is used for building and managing the project:
+   ```bash
+   pip install hatch
+   ```
+
+3. Create a development environment and install dependencies:
+   ```bash
+   hatch env create
+   ```
+
+4. Activate the development environment:
+   ```bash
+   hatch shell
+   ```
+
+### renderers/bbcode.py
+
+The custom plugin for Mistune, which converts AST to bbcode.[^1]
+
+[^1]: Mistune does not convert Markdown HTML to AST, hence the need for `html2bbcode`.
+
+## Additional Tools
+
+### html2bbcode
+
+Converts several HTML tags typically allowed in Markdown to BBCode.[^2]
+
+[^2]: Currently used for post-processing mistune output, but there's a better way. See inside the file for a suggestion.
+
+```bash
+html2bbcode input_file.html
+```
+
+### md2ast
+
+For debugging Mistune's renderer, converts a Markdown file to AST (JSON format).
+
+```bash
+md2ast input.md output.json
+```
+
+## Features Test
+
+Here are a few GitHub-flavored Markdown features so you can use this README.md for testing:
+
+- **Strikethrough:** ~~This text is struck through.~~
+- **Superscript:** This text is normal and this is <sup>superscript</sup>.
+- **Table:**
+
+  | Syntax      | Description |
+  | ----------- | ----------- |
+  | Header      | Title       |
+  | Paragraph   | Text        |
+
+## Todo
+
+- refactor html2bbcode
+- update for new Xenforo 2.3 and 2.4 BBCode

md2bbcode-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+md2bbcode/__about__.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+md2bbcode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+md2bbcode/eqlog.md,sha256=acMtTLnE-kfmRnVq1pZeLUmeLDHgEH6QNWUK-RE7EJU,2182
+md2bbcode/html2bbcode.py,sha256=yONG7DMxx_QBvSExGH0_viw6RnX6_PXDtAubkXvUf2c,6102
+md2bbcode/main.py,sha256=g5Lp_HO6AsT6aYX2g7aUchhNSzyubjyGqUvAuViUR4c,2757
+md2bbcode/md2ast.py,sha256=gsmDTuDyTL7Q25bX2GhDR2TkMg1y3-mte4PnUGYpKk0,1888
+md2bbcode/renderers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+md2bbcode/renderers/bbcode.py,sha256=425aNzLiGvJHlKAlK78jL4HiPtin18sg5oGzzkjK4pY,7807
+md2bbcode-0.1.0.dist-info/METADATA,sha256=OJHafV0w6s5W_kExIg500WGB5mFGBFB_6Bm0ETMcEho,3454
+md2bbcode-0.1.0.dist-info/WHEEL,sha256=fl6v0VwpzfGBVsGtkAkhILUlJxROXbA3HvRL6Fe3140,105
+md2bbcode-0.1.0.dist-info/entry_points.txt,sha256=JUMQnuUEsZ8Fy5vx5O7hYWiD7QWSmByfTFIB1aD6Y9Q,122
+md2bbcode-0.1.0.dist-info/licenses/LICENSE.txt,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+md2bbcode-0.1.0.dist-info/RECORD,,

md2bbcode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

md2bbcode-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+html2bbcode = md2bbcode.html2bbcode:main
+md2ast = md2bbcode.md2ast:main
+md2bbcode = md2bbcode.main:main