webreader 2.3.8__py3-none-any.whl

webreader/selectors.py

@@ -0,0 +1,462 @@
+"""CSS selector engine operating on htmlparser document trees.
+
+Supported syntax: type selectors, ``*``, ``#id``, ``.class``,
+attribute selectors (``[attr]``, ``[attr=value]`` and the
+``^=``, ``$=``, ``*=``, ``~=``, ``|=`` operators), the
+pseudo-classes ``:first-child``, ``:last-child``, ``:nth-child(an+b)``,
+``:not(compound)`` and ``:contains(text)``, compounds such as
+``div.content#main[href="x"]``, the combinators whitespace
+(descendant), ``>`` (child), ``+`` (adjacent sibling) and ``~``
+(general sibling), and comma-separated selector lists.
+"""
+
+import re
+from typing import List, Optional, Tuple
+
+from pafer.exceptions import SelectorSyntaxError
+
+from .core import COMMENT_TAG, ROOT_TAG, Node, ParsedDocument
+
+_IDENT_RE = re.compile(r'[\w-]+')
+_ATTR_RE = re.compile(r'^([\w:.-]+)\s*(\^=|\$=|\*=|~=|\|=|=)\s*(.*)$', re.DOTALL)
+_NTH_RE = re.compile(r'^([+-]?\d*)n(?:\s*([+-])\s*(\d+))?$')
+_INT_RE = re.compile(r'^[+-]?\d+$')
+
+_SUPPORTED_PSEUDOS = {'first-child', 'last-child', 'nth-child', 'not', 'contains'}
+
+
+class _Compound:
+    """A single compound selector such as ``div.menu#main[href="/"]:first-child``."""
+
+    __slots__ = ('tag', 'node_id', 'classes', 'attrs', 'pseudos')
+
+    def __init__(self) -> None:
+        self.tag: Optional[str] = None
+        self.node_id: Optional[str] = None
+        self.classes: List[str] = []
+        self.attrs: List[Tuple[str, Optional[str], Optional[str]]] = []
+        self.pseudos: List[Tuple[str, object]] = []
+
+    def matches(self, node: Node) -> bool:
+        if self.tag not in (None, '*') and node.tag != self.tag:
+            return False
+        if self.node_id is not None and node.get_attr('id') != self.node_id:
+            return False
+        for cls in self.classes:
+            if not node.has_class(cls):
+                return False
+        for name, op, value in self.attrs:
+            if not _match_attr(node, name, op, value):
+                return False
+        for name, arg in self.pseudos:
+            if not _match_pseudo(node, name, arg):
+                return False
+        return True
+
+
+def _match_attr(node: Node, name: str, op: Optional[str],
+                value: Optional[str]) -> bool:
+    actual = node.get_attr(name)
+    if actual is None:
+        return False
+    if op is None:
+        return True
+    if op == '=':
+        return actual == value
+    if op == '|=':
+        return actual == value or actual.startswith(value + '-')
+    if not value:
+        return False
+    if op == '^=':
+        return actual.startswith(value)
+    if op == '$=':
+        return actual.endswith(value)
+    if op == '*=':
+        return value in actual
+    if op == '~=':
+        return value in actual.split()
+    return False
+
+
+def _siblings(node: Node) -> List[Node]:
+    if node.parent is None:
+        return [node]
+    return node.parent.child_elements()
+
+
+def _sibling_index(node: Node) -> int:
+    for index, sibling in enumerate(_siblings(node)):
+        if sibling is node:
+            return index + 1
+    return 1
+
+
+def _sibling_count(node: Node) -> int:
+    return len(_siblings(node))
+
+
+def _match_pseudo(node: Node, name: str, arg: object) -> bool:
+    if name == 'first-child':
+        return _sibling_index(node) == 1
+    if name == 'last-child':
+        return _sibling_index(node) == _sibling_count(node)
+    if name == 'nth-child':
+        step, offset = arg  # type: ignore[misc]
+        return _nth_matches(step, offset, _sibling_index(node))
+    if name == 'not':
+        return not arg.matches(node)  # type: ignore[attr-defined]
+    if name == 'contains':
+        return arg in node.text_content()  # type: ignore[operator]
+    raise SelectorSyntaxError(f'unsupported pseudo-class :{name}')
+
+
+def _parse_nth(text: str) -> Tuple[int, int]:
+    """Translate an :nth-child argument into an (a, b) an+b step form."""
+    value = text.strip().lower().replace(' ', '')
+    if value == 'odd':
+        return (2, 1)
+    if value == 'even':
+        return (2, 0)
+    if _INT_RE.match(value):
+        return (0, int(value))
+    match = _NTH_RE.match(value)
+    if not match:
+        raise SelectorSyntaxError(f'invalid an+b expression {text!r}')
+    a_text = match.group(1)
+    if a_text in ('', '+'):
+        step = 1
+    elif a_text == '-':
+        step = -1
+    else:
+        step = int(a_text)
+    offset = 0
+    if match.group(2):
+        offset = int(match.group(3))
+        if match.group(2) == '-':
+            offset = -offset
+    return (step, offset)
+
+
+def _nth_matches(step: int, offset: int, index: int) -> bool:
+    delta = index - offset
+    if step == 0:
+        return delta == 0
+    if delta % step != 0:
+        return False
+    return delta // step >= 0
+
+
+def _read_parens(text: str, pos: int) -> Tuple[str, int]:
+    """Consume a parenthesized group starting at text[pos] == '('."""
+    depth = 0
+    quote: Optional[str] = None
+    for index in range(pos, len(text)):
+        char = text[index]
+        if quote:
+            if char == quote:
+                quote = None
+            continue
+        if char in '"\'':
+            quote = char
+        elif char == '(':
+            depth += 1
+        elif char == ')':
+            depth -= 1
+            if depth == 0:
+                return text[pos + 1:index], index + 1
+    raise SelectorSyntaxError(f'unbalanced parentheses in {text!r}')
+
+
+def _find_attr_end(text: str, pos: int) -> int:
+    quote: Optional[str] = None
+    for index in range(pos, len(text)):
+        char = text[index]
+        if quote:
+            if char == quote:
+                quote = None
+            continue
+        if char in '"\'':
+            quote = char
+        elif char == ']':
+            return index
+    return -1
+
+
+def _parse_compound(text: str) -> _Compound:
+    compound = _Compound()
+    pos = 0
+    match = _IDENT_RE.match(text, pos)
+    if match and match.start() == pos:
+        compound.tag = match.group(0).lower()
+        pos = match.end()
+    matched = compound.tag is not None
+
+    while pos < len(text):
+        char = text[pos]
+        if char == '*':
+            if pos != 0 or compound.tag is not None:
+                raise SelectorSyntaxError(f'misplaced "*" in {text!r}')
+            compound.tag = '*'
+            pos += 1
+            matched = True
+        elif char == '#':
+            ident = _IDENT_RE.match(text, pos + 1)
+            if not ident:
+                raise SelectorSyntaxError(f'expected identifier after "#" in {text!r}')
+            compound.node_id = ident.group(0)
+            pos = ident.end()
+            matched = True
+        elif char == '.':
+            ident = _IDENT_RE.match(text, pos + 1)
+            if not ident:
+                raise SelectorSyntaxError(f'expected identifier after "." in {text!r}')
+            compound.classes.append(ident.group(0))
+            pos = ident.end()
+            matched = True
+        elif char == '[':
+            end = _find_attr_end(text, pos + 1)
+            if end == -1:
+                raise SelectorSyntaxError(f'unclosed attribute selector in {text!r}')
+            inner = text[pos + 1:end].strip()
+            if not inner:
+                raise SelectorSyntaxError(f'empty attribute selector in {text!r}')
+            _parse_attr(compound, inner, text)
+            pos = end + 1
+            matched = True
+        elif char == ':':
+            pos, matched = _parse_pseudo(compound, text, pos)
+        else:
+            break
+
+    if not matched:
+        raise SelectorSyntaxError(f'invalid selector component: {text!r}')
+    if pos != len(text):
+        raise SelectorSyntaxError(
+            f'unexpected {text[pos:]!r} in selector {text!r} '
+            '(pseudo-classes and functions are not supported)'
+        )
+    return compound
+
+
+def _parse_attr(compound: _Compound, inner: str, text: str) -> None:
+    match = _ATTR_RE.match(inner)
+    if match:
+        name = match.group(1).lower()
+        op = match.group(2)
+        raw_value = match.group(3).strip()
+        quoted = (
+            len(raw_value) >= 2
+            and raw_value[0] == raw_value[-1]
+            and raw_value[0] in '"\''
+        )
+        value = raw_value[1:-1] if quoted else raw_value
+        if not quoted and not raw_value:
+            raise SelectorSyntaxError(f'missing attribute value in {text!r}')
+        compound.attrs.append((name, op, value))
+    elif '=' in inner:
+        raise SelectorSyntaxError(f'invalid attribute selector [{inner}] in {text!r}')
+    else:
+        compound.attrs.append((inner.lower(), None, None))
+
+
+def _parse_pseudo(compound: _Compound, text: str,
+                  pos: int) -> Tuple[int, bool]:
+    ident = _IDENT_RE.match(text, pos + 1)
+    if not ident:
+        raise SelectorSyntaxError(
+            f'expected pseudo-class name after ":" in {text!r}'
+        )
+    name = ident.group(0).lower()
+    pos = ident.end()
+    if name not in _SUPPORTED_PSEUDOS:
+        raise SelectorSyntaxError(f'unsupported pseudo-class :{name} in {text!r}')
+    arg_text: Optional[str] = None
+    if pos < len(text) and text[pos] == '(':
+        arg_text, pos = _read_parens(text, pos)
+
+    if name in ('first-child', 'last-child'):
+        if arg_text is not None:
+            raise SelectorSyntaxError(f':{name} takes no argument')
+        compound.pseudos.append((name, None))
+    elif name == 'nth-child':
+        if arg_text is None:
+            raise SelectorSyntaxError(':nth-child requires an an+b argument')
+        compound.pseudos.append((name, _parse_nth(arg_text)))
+    elif name == 'not':
+        if arg_text is None or not arg_text.strip():
+            raise SelectorSyntaxError(':not requires a selector argument')
+        compound.pseudos.append((name, _parse_compound(arg_text.strip())))
+    else:
+        if arg_text is None:
+            raise SelectorSyntaxError(':contains requires a text argument')
+        value = arg_text.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in '"\'':
+            value = value[1:-1]
+        if not value:
+            raise SelectorSyntaxError(f'empty :contains argument in {text!r}')
+        compound.pseudos.append((name, value))
+    return pos, True
+
+
+def _split_chain(selector: str) -> List[Tuple[Optional[str], _Compound]]:
+    """Split one selector into [(combinator, compound), ...] parts."""
+    parts: List[Tuple[Optional[str], str]] = []
+    buffer: List[str] = []
+    pending: Optional[str] = None
+    brackets = 0
+    parens = 0
+    quote: Optional[str] = None
+    seen_space = False
+
+    for char in selector:
+        if quote:
+            buffer.append(char)
+            if char == quote:
+                quote = None
+            continue
+        if char in '"\'':
+            quote = char
+            buffer.append(char)
+            continue
+        if char == '[':
+            brackets += 1
+        elif char == ']':
+            brackets = max(0, brackets - 1)
+        elif char == '(':
+            parens += 1
+        elif char == ')':
+            parens = max(0, parens - 1)
+        nested = brackets > 0 or parens > 0
+
+        if not nested and char.isspace():
+            if buffer:
+                seen_space = True
+            continue
+        if not nested and char in '>+~':
+            if not buffer:
+                raise SelectorSyntaxError(f'misplaced {char!r} in selector {selector!r}')
+            parts.append((pending, ''.join(buffer)))
+            buffer = []
+            pending = char
+            seen_space = False
+            continue
+        if seen_space and buffer:
+            parts.append((pending, ''.join(buffer)))
+            buffer = []
+            pending = ' '
+        seen_space = False
+        buffer.append(char)
+
+    if not buffer:
+        if parts:
+            raise SelectorSyntaxError(f'selector {selector!r} ends with a combinator')
+        raise SelectorSyntaxError('empty selector')
+    parts.append((pending, ''.join(buffer)))
+    return [(combinator, _parse_compound(text)) for combinator, text in parts]
+
+
+def _prev_element(node: Node) -> Optional[Node]:
+    if node.parent is None:
+        return None
+    siblings = node.parent.child_elements()
+    for index, sibling in enumerate(siblings):
+        if sibling is node:
+            return siblings[index - 1] if index > 0 else None
+    return None
+
+
+def _matches_chain(node: Node, chain: List[Tuple[Optional[str], _Compound]],
+                   index: int) -> bool:
+    combinator, compound = chain[index]
+    if not compound.matches(node):
+        return False
+    if index == 0:
+        return True
+    if combinator == '>':
+        parent = node.parent
+        return parent is not None and _matches_chain(parent, chain, index - 1)
+    if combinator == '+':
+        prev = _prev_element(node)
+        return prev is not None and _matches_chain(prev, chain, index - 1)
+    if combinator == '~':
+        prev = _prev_element(node)
+        while prev is not None:
+            if _matches_chain(prev, chain, index - 1):
+                return True
+            prev = _prev_element(prev)
+        return False
+    ancestor = node.parent
+    while ancestor is not None:
+        if _matches_chain(ancestor, chain, index - 1):
+            return True
+        ancestor = ancestor.parent
+    return False
+
+
+def _iter_scope(scope: Node):
+    if scope.tag not in (ROOT_TAG, COMMENT_TAG):
+        yield scope
+    yield from scope.iter_elements()
+
+
+def _split_selector_list(selector: str) -> List[str]:
+    parts: List[str] = []
+    buffer: List[str] = []
+    brackets = 0
+    parens = 0
+    quote: Optional[str] = None
+    for char in selector:
+        if quote:
+            buffer.append(char)
+            if char == quote:
+                quote = None
+            continue
+        if char in '"\'':
+            quote = char
+        elif char == '[':
+            brackets += 1
+        elif char == ']':
+            brackets = max(0, brackets - 1)
+        elif char == '(':
+            parens += 1
+        elif char == ')':
+            parens = max(0, parens - 1)
+        elif char == ',' and not brackets and not parens:
+            parts.append(''.join(buffer))
+            buffer = []
+            continue
+        buffer.append(char)
+    parts.append(''.join(buffer))
+    return parts
+
+
+def select_nodes(scope, selector: str) -> List[Node]:
+    """Return all element nodes matching the selector, in document order."""
+    root = scope.root if isinstance(scope, ParsedDocument) else scope
+    chains = []
+    for part in _split_selector_list(selector):
+        part = part.strip()
+        if not part:
+            raise SelectorSyntaxError('empty selector in selector list')
+        chains.append(_split_chain(part))
+    results: List[Node] = []
+    seen = set()
+    for node in _iter_scope(root):
+        for chain in chains:
+            if _matches_chain(node, chain, len(chain) - 1):
+                if id(node) not in seen:
+                    seen.add(id(node))
+                    results.append(node)
+                break
+    return results
+
+
+def find_all(scope, selector: str) -> List[Node]:
+    """Return every element matching the selector."""
+    return select_nodes(scope, selector)
+
+
+def find(scope, selector: str) -> Optional[Node]:
+    """Return the first element matching the selector, or None."""
+    nodes = select_nodes(scope, selector)
+    return nodes[0] if nodes else None

webreader-2.3.8.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: webreader
+Version: 2.3.8
+Summary: Tree-based HTML reader for Python.
+Author-email: morichan <morichan@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pafer
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+![Python](https://img.shields.io/badge/python-3.8%2B-blue)
+![Dependencies](https://img.shields.io/badge/dependencies-none-success)
+![Tests](https://img.shields.io/badge/tests-pytest-informational)
+
+## Features
+
+- Tree-based parsing into an editable document tree
+- CSS selectors: combinators, attributes, pseudo-classes, selector lists
+- Extractors: metadata, links, tables, text, images, forms, headings,
+  scripts, stylesheets
+- Sanitization with a removal report
+- Minify, pretty-print, Markdown conversion
+- JSON / CSV / Markdown export
+- CLI tool
+- Standard library only at runtime
+
+## Installation
+
+```
+pip install webreader
+```
+
+## Quickstart
+
+```python
+import webreader
+
+html = '<h1 class="title">Hello</h1><a href="/x">link</a>'
+doc = webreader.parse(html)
+
+webreader.select(doc, 'h1.title')   # [{'tag': ..., 'attrs': ..., 'text': ..., 'html': ...}]
+doc.find('a').get_attr('href')       # '/x'
+
+webreader.minify(html)              # collapsed whitespace
+webreader.pretty(html)              # re-indented, readable markup
+webreader.to_markdown(html)         # convert to Markdown
+
+clean, report = webreader.sanitize(html)
+```
+
+Bytes input is decoded using detected encoding: BOM sniffing first,
+then `<meta charset>` in the first 2 KB, then the configured
+`encoding` fallback.
+
+In non-strict mode, malformed HTML does not raise; the warnings are
+available on the document:
+
+```python
+doc = webreader.parse('<div><p>x</p>')   # unclosed <div>
+doc.errors                                 # ['unclosed tag(s) at end of input: <div>']
+```
+
+## Extraction
+
+```python
+webreader.extract_metadata(html)    # title, OG/Twitter, canonical, charset, JSON-LD
+webreader.extract_links(html)       # links and asset references
+webreader.extract_tables(html)      # matrices with colspan/rowspan expanded
+webreader.extract_text(html)        # readable text without boilerplate
+webreader.extract_images(html)      # src, alt, dimensions, srcset candidates
+webreader.extract_forms(html)       # form fields with types and defaults
+webreader.extract_headings(html)    # h1-h6 outline + word count + reading time
+webreader.extract_scripts(html)     # inline and external script inventory
+webreader.extract_stylesheets(html) # link[rel~=stylesheet] and inline styles
+```
+
+## CSS selectors
+
+Supported syntax: type selectors, `*`, `#id`, `.class`, attribute
+selectors (`[attr]`, `[attr=value]` and the `^=`, `$=`, `*=`, `~=`,
+`|=` operators), the pseudo-classes `:first-child`, `:last-child`,
+`:nth-child(an+b)`, `:not(compound)` and `:contains(text)`, compounds
+such as `div.content#main[href="x"]`, the combinators whitespace
+(descendant), `>` (child), `+` (adjacent sibling) and `~` (general
+sibling), and comma-separated selector lists.
+
+```python
+webreader.select(doc, 'a[href^="https://"]')
+webreader.select(doc, 'ul > li:nth-child(2n+1):not(.skip)')
+webreader.select(doc, 'h2 + p, blockquote p:contains("note")')
+```
+
+Invalid or unsupported selectors raise `SelectorSyntaxError`.
+
+## Tree editing
+
+Nodes support a mutation API, and the edited tree can be
+re-serialized:
+
+```python
+doc = webreader.parse('<div><a href="/x">link</a></div>')
+link = doc.find('a')
+link.set_attr('rel', 'noopener').remove_attr('class')
+
+new = webreader.Node('p')
+new.children.append('added text')
+doc.find('div').append_child(new)
+
+link.unwrap()        # replace the <a> with its inner text
+doc.to_html()        # '<div>link<p>added text</p></div>'
+```
+
+`Node` also provides `remove()` and `replace_with(*nodes)`.
+
+## Markdown conversion
+
+`to_markdown` renders headings, paragraphs, links, images,
+emphasis/strong/strikethrough, inline and fenced code (with language
+detection from `class="language-..."`), nested lists, blockquotes,
+horizontal rules and tables.
+
+```python
+webreader.to_markdown('<h1>T</h1><p>Hi <b>bold</b></p>')
+# '# T\n\nHi **bold**'
+```
+
+## Sanitization
+
+`sanitize()` returns `(clean_html, report)`:
+
+- tags outside the whitelist are unwrapped, inner content kept
+- `script`, `style`, `noscript`, `template` are dropped entirely
+- attributes filtered through a safe-list, `on*` handlers removed
+- `javascript:`, `vbscript:` and non-image `data:` URLs blocked
+- the report lists removed tags/attributes, blocked URLs and detected threats
+
+## CLI
+
+```
+python -m webreader parse -f input.html
+python -m webreader select -f input.html -s 'a[href]'
+python -m webreader links -f input.html --base-url https://example.com
+python -m webreader meta -f input.html
+python -m webreader tables -f input.html --format csv
+python -m webreader text -f input.html
+python -m webreader images -f input.html
+python -m webreader forms -f input.html
+python -m webreader minify -f input.html --out min.html
+python -m webreader pretty -f input.html --out pretty.html
+python -m webreader md -f input.html --out page.md
+python -m webreader sanitize -f input.html --out clean.html --allowed p,a,ul
+```
+
+Use `-f -` to read from stdin. Every output command accepts `--out`
+to write to a file instead of stdout.
+
+### Default settings
+
+| Key | Default | Purpose |
+|---|---|---|
+| `strip_whitespace` | `True` | collapse whitespace in text nodes |
+| `encoding` | `utf-8` | fallback when bytes input has no detectable encoding |
+| `max_depth` | `100` | maximum element nesting |
+| `preserve_comments` | `False` | keep comments in the tree |
+| `strict_mode` | `False` | raise on malformed HTML |
+| `remove_comments` | `True` | strip comments when minifying |
+| `allowed_tags` | `p, br, b, i, a, ul, ol, li, div, span` | sanitize whitelist |
+| `max_file_size_mb` | `10` | reject oversized input |
+| `cache_size` | `50` | parse cache capacity |
+
+## Exceptions
+
+`HTMLPaferError` (base), `ConfigLoadError`, `SanitizationError`,
+`SelectorSyntaxError`.

webreader-2.3.8.dist-info/RECORD

@@ -0,0 +1,15 @@
+webreader/__init__.py,sha256=B_7GIR-PD0ovIEB4ohEIqMfg0H9BcgOY5d8aAEhkUfc,5939
+webreader/__main__.py,sha256=IddtPdFVJkK7fQzXzTwQR53faIh0ou_fecp66SYwJZ8,118
+webreader/cli.py,sha256=K0SSg5FGX3pRAeFDQT3eOSrvT0DxOIG0dum2xGwuQP0,6257
+webreader/core.py,sha256=BGxJH-rdv7hU7x9tgd2gM_ZJ3wIMLeicLJgE-87eR3s,17135
+webreader/default.config,sha256=u-MHw9NH_3pXs2MH6oD56T2o6H1qc404glYOwrho43I,3912
+webreader/extractors.py,sha256=8SStkNjKBJOFlqZYkiw6d3tUCdvGXSaO_uCR5UZqDL0,14759
+webreader/formatter.py,sha256=53BZwv7ITE76gI1q5fpoKMOZOk_4_VnYmmrZYxDlr2I,2758
+webreader/markdown.py,sha256=rbtCGjh8YK-o5KRoIYAmM0CJbVd3I1YlsVPweqsNjtY,7059
+webreader/sanitizer.py,sha256=DKq8COXQAMs1uTqi3KWojZV6ZXZ13dD3dTrJgtRayfo,4085
+webreader/selectors.py,sha256=xSekLdo86iYo5Fp1YGj7rrtC_hLekMBzA8sReY9wdUw,15240
+webreader-2.3.8.dist-info/licenses/LICENSE,sha256=WoBhv4IiumWxRgU4WdprWpi1RZavGc7_PC-GMwbHgtI,1087
+webreader-2.3.8.dist-info/METADATA,sha256=UpnK17gZysOtnAMc-EEq4k1TWTAMoTfbiVhuXwk6auo,6753
+webreader-2.3.8.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+webreader-2.3.8.dist-info/top_level.txt,sha256=InRfwO2sKc1fq2AmIyxTgfO2jCM5ivfqoDOZRRmejCg,10
+webreader-2.3.8.dist-info/RECORD,,

webreader-2.3.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

webreader-2.3.8.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 webreader
+
+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.

webreader-2.3.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+webreader