draftjs_exporter 5.2.0__py3-none-any.whl

draftjs_exporter/wrapper_state.py

@@ -0,0 +1,170 @@
+from typing import List, Optional, Sequence, Union
+
+from draftjs_exporter.constants import BLOCK_TYPES
+from draftjs_exporter.dom import DOM
+from draftjs_exporter.options import Options, OptionsMap
+from draftjs_exporter.types import Block, Element, Props, RenderableType
+
+
+class Wrapper:
+    """
+    A wrapper is an element that wraps other nodes. It gets created
+    when the depth of a block is different than 0, so the DOM elements
+    have the appropriate amount of nesting.
+    """
+
+    __slots__ = ("depth", "last_child", "type", "props", "elt")
+
+    def __init__(self, depth: int, options: Optional[Options] = None) -> None:
+        self.depth = depth
+        self.last_child = None
+
+        if options:
+            self.type = options.wrapper
+            self.props = options.wrapper_props
+
+            wrapper_props = dict(self.props) if self.props else {}
+            wrapper_props["block"] = {"type": options.type, "depth": depth}
+
+            self.elt = DOM.create_element(self.type, wrapper_props)
+        else:
+            self.type = None
+            self.props = None
+            self.elt = DOM.create_element()
+
+    def is_different(
+        self, depth: int, type_: RenderableType, props: Optional[Props]
+    ) -> bool:
+        return depth > self.depth or type_ != self.type or props != self.props
+
+
+class WrapperStack:
+    """
+    Stack data structure for element wrappers.
+    The bottom of the stack contains the elements closest to the page body.
+    The top of the stack contains the most nested nodes.
+    """
+
+    __slots__ = "stack"
+
+    def __init__(self) -> None:
+        self.stack: List[Wrapper] = []
+
+    def __str__(self) -> str:
+        return str(self.stack)
+
+    def length(self) -> int:
+        return len(self.stack)
+
+    def append(self, wrapper: Wrapper) -> None:
+        return self.stack.append(wrapper)
+
+    def get(self, index: int) -> Wrapper:
+        return self.stack[index]
+
+    def slice(self, length: int) -> None:
+        self.stack = self.stack[:length]
+
+    def head(self) -> Wrapper:
+        if self.length() > 0:
+            wrapper = self.stack[-1]
+        else:
+            wrapper = Wrapper(-1)
+
+        return wrapper
+
+    def tail(self) -> Wrapper:
+        return self.stack[0]
+
+
+class WrapperState:
+    """
+    This class does the initial node building for the tree.
+    It sets elements with the right tag, text content, and props.
+    It adds a wrapper element around elements, if required.
+    """
+
+    __slots__ = ("block_options", "blocks", "stack")
+
+    def __init__(self, block_options: OptionsMap, blocks: Sequence[Block]) -> None:
+        self.block_options = block_options
+        self.blocks = blocks
+        self.stack = WrapperStack()
+
+    def __str__(self) -> str:
+        return f"<WrapperState: {self.stack}>"
+
+    def element_for(
+        self, block: Block, block_content: Union[Element, Sequence[Element]]
+    ) -> Element:
+        type_ = block["type"] if "type" in block else "unstyled"
+        depth = block["depth"] if "depth" in block else 0
+        options = Options.get(self.block_options, type_, BLOCK_TYPES.FALLBACK)
+        props = dict(options.props)
+        props["block"] = block
+        props["blocks"] = self.blocks
+
+        # Make an element from the options specified in the block map.
+        elt = DOM.create_element(options.element, props, block_content)
+
+        parent = self.parent_for(options, depth, elt)
+
+        return parent
+
+    def parent_for(self, options: Options, depth: int, elt: Element) -> Element:
+        if options.wrapper:
+            parent = self.get_wrapper_elt(options, depth)
+            DOM.append_child(parent, elt)
+            self.stack.stack[-1].last_child = elt
+        else:
+            # Reset the stack if there is no wrapper.
+            if self.stack.length() > 0:
+                self.stack = WrapperStack()
+            parent = elt
+
+        return parent
+
+    def get_wrapper_elt(self, options: Options, depth: int) -> Element:
+        head = self.stack.head()
+        if head.is_different(depth, options.wrapper, options.wrapper_props):
+            self.update_stack(options, depth)
+
+        # If depth is lower than the maximum, we cut the stack.
+        if depth < head.depth:
+            self.stack.slice(depth + 1)
+
+        return self.stack.get(depth).elt
+
+    def update_stack(self, options: Options, depth: int) -> None:
+        if depth >= self.stack.length():
+            # If the depth is gte the stack length, we need more wrappers.
+            depth_levels = range(self.stack.length(), depth + 1)
+
+            for level in depth_levels:
+                new_wrapper = Wrapper(level, options)
+
+                # Determine where to append the new wrapper.
+                if self.stack.head().last_child is None:
+                    # If there is no content in the current wrapper, we need
+                    # to add an intermediary node.
+                    props = dict(options.props)
+                    props["block"] = {
+                        "type": options.type,
+                        "depth": depth,
+                        "data": {},
+                    }
+                    props["blocks"] = self.blocks
+
+                    wrapper_parent = DOM.create_element(options.element, props)
+                    DOM.append_child(self.stack.head().elt, wrapper_parent)
+                else:
+                    # Otherwise we can append at the end of the last child.
+                    wrapper_parent = self.stack.head().last_child
+
+                DOM.append_child(wrapper_parent, new_wrapper.elt)
+
+                self.stack.append(new_wrapper)
+        else:
+            # Cut the stack to where it now stops, and add new wrapper.
+            self.stack.slice(depth)
+            self.stack.append(Wrapper(depth, options))

draftjs_exporter-5.2.0.dist-info/METADATA

@@ -0,0 +1,376 @@
+Metadata-Version: 2.3
+Name: draftjs_exporter
+Version: 5.2.0
+Summary: Library to convert rich text from Draft.js raw ContentState to HTML
+Author: Springload
+Author-email: Springload <hello@springload.co.nz>
+License: # The MIT License (MIT)
+         
+         Copyright (c) 2016-current Springload
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Internet :: WWW/HTTP :: Site Management
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Editors :: Word Processors
+Classifier: Typing :: Typed
+Requires-Dist: beautifulsoup4>=4.4.1,<5 ; extra == 'html5lib'
+Requires-Dist: html5lib>=0.999,<2 ; extra == 'html5lib'
+Requires-Dist: lxml>=4.2.0,<7 ; extra == 'lxml'
+Project-URL: Changelog, https://github.com/springload/draftjs_exporter/blob/main/CHANGELOG.md
+Project-URL: Source, https://github.com/springload/draftjs_exporter
+Project-URL: Tracker, https://github.com/springload/draftjs_exporter/issues
+Provides-Extra: html5lib
+Provides-Extra: lxml
+Description-Content-Type: text/markdown
+
+# [Draft.js exporter](https://pypi.org/project/draftjs_exporter/)
+
+> Library to convert rich text from Draft.js raw ContentState to HTML.
+
+It is developed alongside the [Draftail](https://www.draftail.org/) rich text editor, for [Wagtail](https://github.com/wagtail/wagtail). Check out the [online demo](http://playground.draftail.org/), and our [introductory blog post](https://www.draftail.org/blog/2018/03/13/rethinking-rich-text-pipelines-with-draft-js).
+
+## Why
+
+[Draft.js](https://draftjs.org/) is a rich text editor framework for [React](https://reactjs.org/). Its approach is different from most rich text editors because it does not store data as HTML, but rather in its own representation called ContentState. This exporter is useful when the ContentState to HTML conversion has to be done in a Python ecosystem.
+
+The initial use case was to gain more control over the content managed by rich text editors in a Wagtail/Django site. If you want to read the full story, have a look at our blog post: [Rethinking rich text pipelines with Draft.js](https://www.draftail.org/blog/2018/03/13/rethinking-rich-text-pipelines-with-draft-js).
+
+## Features
+
+This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html), and [measures performance](https://thib.me/python-memory-profiling-for-the-draft-js-exporter) and [code coverage](https://coveralls.io/github/springload/draftjs_exporter). Code is checked with [mypy](https://mypy.readthedocs.io/en/latest/index.html).
+
+- Extensive configuration of the generated HTML.
+- Default, extensible block & inline style maps for common HTML elements.
+- Convert line breaks to `<br>` elements.
+- Define any attribute in the block map – custom class names for elements.
+- React-like API to create custom components.
+- Automatic conversion of entity data to HTML attributes (int & boolean to string, style object to style string).
+- Nested lists (`<li>` elements go inside `<ul>` or `<ol>`, with multiple levels).
+- Output inline styles as inline elements (`<em>`, `<strong>`, pick and choose, with any attribute).
+- Overlapping inline style and entity ranges.
+- Static type annotations.
+
+## Usage
+
+Draft.js stores data in a JSON representation based on blocks, representing lines of content in the editor, annotated with entities and styles to represent rich text. For more information, [this article](https://medium.com/@rajaraodv/how-draft-js-represents-rich-text-data-eeabb5f25cf2) covers the concepts further.
+
+### Getting started
+
+This exporter takes the Draft.js ContentState data as input, and outputs HTML based on its configuration. To get started, install the package:
+
+```sh
+pip install draftjs_exporter
+```
+
+We support the following Python versions: 3.9, 3.10, 3.11, 3.12, 3.13, 3.14. For legacy Python versions, find compatible releases in the [CHANGELOG](https://github.com/springload/draftjs_exporter/blob/main/CHANGELOG.md).
+
+In your code, create an exporter and use the `render` method to create HTML:
+
+```python
+from draftjs_exporter.dom import DOM
+from draftjs_exporter.html import HTML
+
+# Configuration options are detailed below.
+config = {}
+
+# Initialize the exporter.
+exporter = HTML(config)
+
+# Render a Draft.js `contentState`
+html = exporter.render({
+    'entityMap': {},
+    'blocks': [{
+        'key': '6m5fh',
+        'text': 'Hello, world!',
+        'type': 'unstyled',
+        'depth': 0,
+        'inlineStyleRanges': [],
+        'entityRanges': []
+    }]
+})
+
+print(html)
+```
+
+You can also run an example by downloading this repository and then using `python example.py`, or by using our [online Draft.js demo](http://playground.draftail.org/).
+
+### Configuration
+
+The exporter output is extensively configurable to cater for varied rich text requirements.
+
+```python
+# draftjs_exporter provides default configurations and predefined constants for reuse.
+from draftjs_exporter.constants import BLOCK_TYPES, ENTITY_TYPES
+from draftjs_exporter.defaults import BLOCK_MAP, STYLE_MAP
+from draftjs_exporter.dom import DOM
+
+config = {
+    # `block_map` is a mapping from Draft.js block types to a definition of their HTML representation.
+    # Extend BLOCK_MAP to start with sane defaults, or make your own from scratch.
+    'block_map': dict(BLOCK_MAP, **{
+        # The most basic mapping format, block type to tag name.
+        BLOCK_TYPES.HEADER_TWO: 'h2',
+        # Use a dict to define props on the block.
+        BLOCK_TYPES.HEADER_THREE: {'element': 'h3', 'props': {'class': 'u-text-center'}},
+        # Add a wrapper (and wrapper_props) to wrap adjacent blocks.
+        BLOCK_TYPES.UNORDERED_LIST_ITEM: {
+            'element': 'li',
+            'wrapper': 'ul',
+            'wrapper_props': {'class': 'bullet-list'},
+        },
+        # Use a custom component for more flexibility (reading block data or depth).
+        BLOCK_TYPES.BLOCKQUOTE: blockquote,
+        BLOCK_TYPES.ORDERED_LIST_ITEM: {
+            'element': list_item,
+            'wrapper': ordered_list,
+        },
+        # Provide a fallback component (advanced).
+        BLOCK_TYPES.FALLBACK: block_fallback
+    }),
+    # `style_map` defines the HTML representation of inline elements.
+    # Extend STYLE_MAP to start with sane defaults, or make your own from scratch.
+    'style_map': dict(STYLE_MAP, **{
+        # Use the same mapping format as in the `block_map`.
+        'KBD': 'kbd',
+        # The `style` prop can be defined as a dict, that will automatically be converted to a string.
+        'HIGHLIGHT': {'element': 'strong', 'props': {'style': {'textDecoration': 'underline'}}},
+        # Provide a fallback component (advanced).
+        INLINE_STYLES.FALLBACK: style_fallback,
+    }),
+    'entity_decorators': {
+        # Map entities to components so they can be rendered with their data.
+        ENTITY_TYPES.IMAGE: image,
+        ENTITY_TYPES.LINK: link
+        # Lambdas work too.
+        ENTITY_TYPES.HORIZONTAL_RULE: lambda props: DOM.create_element('hr'),
+        # Discard those entities.
+        ENTITY_TYPES.EMBED: None,
+        # Provide a fallback component (advanced).
+        ENTITY_TYPES.FALLBACK: entity_fallback,
+    },
+    'composite_decorators': [
+        # Use composite decorators to replace text based on a regular expression.
+        {
+            'strategy': re.compile(r'\n'),
+            'component': br,
+        },
+        {
+            'strategy': re.compile(r'#\w+'),
+            'component': hashtag,
+        },
+        {
+            'strategy': LINKIFY_RE,
+            'component': linkify,
+        },
+    ],
+}
+```
+
+See [examples.py](example.py) for more details.
+
+## Advanced usage
+
+### Custom components
+
+To generate arbitrary markup with dynamic data, the exporter comes with an API to create rendering components. This API mirrors React’s [createElement](https://facebook.github.io/react/docs/top-level-api.html#react.createelement) API (what JSX compiles to).
+
+```python
+# All of the API is available from a single `DOM` namespace
+from draftjs_exporter.dom import DOM
+
+
+# Components are simple functions that take `props` as parameter and return DOM elements.
+def image(props):
+    # This component creates an image element, with the relevant attributes.
+    return DOM.create_element('img', {
+        'src': props.get('src'),
+        'width': props.get('width'),
+        'height': props.get('height'),
+        'alt': props.get('alt'),
+    })
+
+
+def blockquote(props):
+    # This component uses block data to render a blockquote.
+    block_data = props['block']['data']
+
+    # Here, we want to display the block's content so we pass the `children` prop as the last parameter.
+    return DOM.create_element('blockquote', {
+        'cite': block_data.get('cite')
+    }, props['children'])
+
+
+def button(props):
+    href = props.get('href', '#')
+    icon_name = props.get('icon', None)
+    text = props.get('text', '')
+
+    return DOM.create_element('a', {
+            'class': 'icon-text' if icon_name else None,
+            'href': href,
+        },
+        # There can be as many `children` as required.
+        # It is also possible to reuse other components and render them instead of HTML tags.
+        DOM.create_element(icon, {'name': icon_name}) if icon_name else None,
+        DOM.create_element('span', {'class': 'icon-text'}, text) if icon_name else text
+    )
+```
+
+Apart from `create_element`, a `parse_html` method is also available. Use it to interface with other HTML generators, like template engines – at your own risk: that method does not sanitize the input.
+
+See `examples.py` in the repository for more details.
+
+### Fallback components
+
+When dealing with changes in the content schema, as part of ongoing development or migrations, some content can go stale.
+To solve this, the exporter allows the definition of fallback components for blocks, styles, and entities.
+This feature is only used for development at the moment, if you have a use case for this in production we would love to hear from you.
+Please get in touch!
+
+Add the following to the exporter config,
+
+```python
+config = {
+    'block_map': dict(BLOCK_MAP, **{
+        # Provide a fallback for block types.
+        BLOCK_TYPES.FALLBACK: block_fallback
+    }),
+}
+```
+
+This fallback component can now control the exporter behavior when normal components are not found. Here is an example:
+
+```python
+def block_fallback(props):
+    type_ = props['block']['type']
+
+    if type_ == 'example-discard':
+        logging.warning(f'Missing config for "{type_}". Discarding block, keeping content.')
+        # Directly return the block's children to keep its content.
+        return props['children']
+    elif type_ == 'example-delete':
+        logging.error(f'Missing config for "{type_}". Deleting block.')
+        # Return None to not render anything, removing the whole block.
+        return None
+    else:
+        logging.warning(f'Missing config for "{type_}". Using div instead.')
+        # Provide a fallback.
+        return DOM.create_element('div', {}, props['children'])
+```
+
+See `examples.py` in the repository for more details.
+
+### Alternative backing engines
+
+By default, the exporter uses a dependency-free engine called `string` to build the DOM tree. There are alternatives:
+
+- `html5lib` (via BeautifulSoup)
+- `lxml`.
+- `string_compat` (A variant of `string` with no backwards-incompatible changes since its first release).
+
+The `string` engine is the fastest, and does not have any dependencies. Its only drawback is that the `parse_html` method does not escape/sanitize HTML like that of other engines.
+
+- For `html5lib`, do `pip install draftjs_exporter[html5lib]`.
+- For `lxml`, do `pip install draftjs_exporter[lxml]`. It also requires `libxml2` and `libxslt` to be available on your system.
+- There are no additional dependencies for `string_compat`.
+
+Then, use the `engine` attribute of the exporter config:
+
+```python
+config = {
+    # Specify which DOM backing engine to use.
+    'engine': DOM.HTML5LIB,
+    # Or for lxml:
+    'engine': DOM.LXML,
+    # Or to use the "maximum output stability" string_compat engine:
+    'engine': DOM.STRING_COMPAT,
+}
+```
+
+To use the `lxml` or `html5lib` engines with arbitrary versions of those dependencies, simply install `draftjs_exporter` without the extras, and separately install the desired versions of the dependencies.
+
+### Custom backing engines
+
+The exporter supports using custom engines to generate its output via the `DOM` API. This can be useful to implement custom export formats, e.g. [to Markdown (experimental)](https://github.com/thibaudcolas/draftjs_exporter_markdown).
+
+Here is an example implementation:
+
+```python
+from draftjs_exporter import DOMEngine
+
+class DOMListTree(DOMEngine):
+    """
+    Element tree using nested lists.
+    """
+
+    @staticmethod
+    def create_tag(t, attr=None):
+        return [t, attr, []]
+
+    @staticmethod
+    def append_child(elt, child):
+        elt[2].append(child)
+
+    @staticmethod
+    def render(elt):
+        return elt
+
+
+exporter = HTML({
+    # Use the dotted module syntax to point to the DOMEngine implementation.
+    'engine': 'my_project.example.DOMListTree'
+})
+```
+
+### Type annotations
+
+The exporter’s codebase uses static type annotations, checked with mypy. Reusable types are made available:
+
+```python
+from draftjs_exporter.dom import DOM
+from draftjs_exporter.types import Element, Props
+
+
+# Components are simple functions that take `props` as parameter and return DOM elements.
+def image(props: Props) -> Element:
+    # This component creates an image element, with the relevant attributes.
+    return DOM.create_element('img', {
+        'src': props.get('src'),
+        'width': props.get('width'),
+        'height': props.get('height'),
+        'alt': props.get('alt'),
+    })
+```
+
+## Contributing
+
+See anything you like in here? Anything missing? We welcome all support, whether on bug reports, feature requests, code, design, reviews, tests, documentation, and more. Please have a look at our [contribution guidelines](docs/CONTRIBUTING.md).
+
+If you just want to set up the project on your own computer, the contribution guidelines also contain all of the setup commands.
+
+## Credits
+
+This project is made possible by the work of [Springload](https://github.com/springload), a New Zealand digital agency. The _beautiful_ demo site is the work of [@thibaudcolas](https://github.com/thibaudcolas).
+
+View the full list of [contributors](https://github.com/springload/draftjs_exporter/graphs/contributors). [MIT licensed](LICENSE).

draftjs_exporter-5.2.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+draftjs_exporter/__init__.py,sha256=9aiFtigUoqawfhgRL3b4QxYRTFSNblKNSglkDnJ54zY,151
+draftjs_exporter/command.py,sha256=2vGMKJJsCfSLSxQnZdw0D-4YemXQULcvIjh1ug9tZmQ,1870
+draftjs_exporter/composite_decorators.py,sha256=-LBrX11e-cMtoxhpyLoId1tIZo-2y1BvvsgBvt_y_Z4,2316
+draftjs_exporter/constants.py,sha256=ZyyiMSr_sSW0tx2JatPVK9cvXj0zn09bS7-HbK-6suE,1446
+draftjs_exporter/defaults.py,sha256=_qg4jzN16JLU5k0i4ss6GhSN3YsJSI3dPS_yoUS-1no,1811
+draftjs_exporter/dom.py,sha256=ayQKauPMhDRFyxmryji9gzAZFSLuU3v-RXlplevvaZY,4170
+draftjs_exporter/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+draftjs_exporter/engines/base.py,sha256=wsaXUlGwfjtx4eRcj0SLKAehqu2K2tbaWUj7XCiNlVQ,1352
+draftjs_exporter/engines/html5lib.py,sha256=8BwxWjhQDQxH5Wg_52fOPGn_-vJk0o-euj2hlKaP7qU,1167
+draftjs_exporter/engines/lxml.py,sha256=guWrLkLSw9sVwvOduLz9_3j9j3FKhS5EUkqxCAgOFcw,1354
+draftjs_exporter/engines/string.py,sha256=rCMShBZ7_XyUuqT7WItzBwV37rU0DrRRXHQP0bB8b68,3372
+draftjs_exporter/engines/string_compat.py,sha256=t7tRE4a87mPg4_vp62gLX-85q65dKusclSui4SeApD8,2129
+draftjs_exporter/entity_state.py,sha256=HHCF1XEqjy35fZGQ79y13-_w9KDlL6nzsQkXtJ_WzxA,3436
+draftjs_exporter/error.py,sha256=AoliTlMGITidJ7uzNyaE4VNU7xcBd0RIeKh8HRwXvDk,98
+draftjs_exporter/html.py,sha256=QFUXoUnqL5HEHXmKa_WpSxymY886b7ymMspM0VzqR_s,6563
+draftjs_exporter/options.py,sha256=djx4ZEiRUVkPyYKKGP6VR5nod7WvPGvh9Dtuo9VpfjU,3195
+draftjs_exporter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+draftjs_exporter/style_state.py,sha256=s3eVYQCR8yMuDOH0egjcAZQSGjAtvL6699wjoghyhQc,1709
+draftjs_exporter/types.py,sha256=ycNWphOixDPqcYSoFPlbK3YEfUX_scn2sKbxbgwpm6U,1344
+draftjs_exporter/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+draftjs_exporter/utils/module_loading.py,sha256=iqZsLMocK84rfxXZ5V5Rp8IbKH0fOGu9yGUGspZ5GDw,828
+draftjs_exporter/wrapper_state.py,sha256=xL54P7KIJfNsdfM239e9B4Z5hnNe1DbN9L5NZxDlohQ,5782
+draftjs_exporter-5.2.0.dist-info/WHEEL,sha256=RRVLqVugUmFOqBedBFAmA4bsgFcROUBiSUKlERi0Hcg,79
+draftjs_exporter-5.2.0.dist-info/METADATA,sha256=8oSHYtj2jgG0f3KxsJ7XLUWa0r9sbyHImXWY8X4jHm4,16410
+draftjs_exporter-5.2.0.dist-info/RECORD,,

draftjs_exporter-5.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.21
+Root-Is-Purelib: true
+Tag: py3-none-any