omlish 0.0.0.dev169__py3-none-any.whl → 0.0.0.dev170__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev169'
-__revision__ = 'ad8bd22d9c1cd7a5a22af3b9d27906ce64fd8451'
+__version__ = '0.0.0.dev170'
+__revision__ = 'be0f1bb54e3cbc28c30a174a14aa4790f265a33a'
 
 
 #

omlish/antlr/_runtime/__init__.py

@@ -1,24 +1,2 @@
-# type: ignore
 # ruff: noqa
 # flake8: noqa
-from .Token import Token
-from .InputStream import InputStream
-from .FileStream import FileStream
-from .StdinStream import StdinStream
-from .BufferedTokenStream import TokenStream
-from .CommonTokenStream import CommonTokenStream
-from .Lexer import Lexer
-from .Parser import Parser
-from .dfa.DFA import DFA
-from .atn.ATN import ATN
-from .atn.ATNDeserializer import ATNDeserializer
-from .atn.LexerATNSimulator import LexerATNSimulator
-from .atn.ParserATNSimulator import ParserATNSimulator
-from .atn.PredictionMode import PredictionMode
-from .PredictionContext import PredictionContextCache
-from .ParserRuleContext import RuleContext, ParserRuleContext
-from .tree.Tree import ParseTreeListener, ParseTreeVisitor, ParseTreeWalker, TerminalNode, ErrorNode, RuleNode
-from .error.Errors import RecognitionException, IllegalStateException, NoViableAltException
-from .error.ErrorStrategy import BailErrorStrategy
-from .error.DiagnosticErrorListener import DiagnosticErrorListener
-from .Utils import str_list

omlish/antlr/_runtime/_all.py

@@ -0,0 +1,24 @@
+# ruff: noqa
+# flake8: noqa
+# type: ignore
+from .Token import Token
+from .InputStream import InputStream
+from .FileStream import FileStream
+from .StdinStream import StdinStream
+from .BufferedTokenStream import TokenStream
+from .CommonTokenStream import CommonTokenStream
+from .Lexer import Lexer
+from .Parser import Parser
+from .dfa.DFA import DFA
+from .atn.ATN import ATN
+from .atn.ATNDeserializer import ATNDeserializer
+from .atn.LexerATNSimulator import LexerATNSimulator
+from .atn.ParserATNSimulator import ParserATNSimulator
+from .atn.PredictionMode import PredictionMode
+from .PredictionContext import PredictionContextCache
+from .ParserRuleContext import RuleContext, ParserRuleContext
+from .tree.Tree import ParseTreeListener, ParseTreeVisitor, ParseTreeWalker, TerminalNode, ErrorNode, RuleNode
+from .error.Errors import RecognitionException, IllegalStateException, NoViableAltException
+from .error.ErrorStrategy import BailErrorStrategy
+from .error.DiagnosticErrorListener import DiagnosticErrorListener
+from .Utils import str_list

omlish/antlr/_runtime/atn/ParserATNSimulator.py

@@ -235,7 +235,7 @@
 # the input.</p>
 #
 import sys
-from .. import DFA
+from ..dfa.DFA import DFA
 from ..BufferedTokenStream import TokenStream
 from ..Parser import Parser
 from ..ParserRuleContext import ParserRuleContext

omlish/antlr/_runtime/dfa/DFASerializer.py

@@ -9,7 +9,7 @@
 
 # A DFA walker that knows how to dump them to serialized strings.#/
 from io import StringIO
-from .. import DFA
+from ..dfa.DFA import DFA
 from ..Utils import str_list
 from .DFAState import DFAState
 

omlish/antlr/_runtime/error/DiagnosticErrorListener.py

@@ -28,7 +28,8 @@
 # </ul>
 
 from io import StringIO
-from .. import Parser, DFA
+from ..Parser import Parser
+from ..dfa.DFA import DFA
 from ..atn.ATNConfigSet import ATNConfigSet
 from .ErrorListener import ErrorListener
 

omlish/antlr/_runtime/xpath/XPath.py

@@ -50,7 +50,13 @@
 # <p>
 # Whitespace is not allowed.</p>
 #
-from .. import CommonTokenStream, DFA, PredictionContextCache, Lexer, LexerATNSimulator, ParserRuleContext, TerminalNode
+from ..CommonTokenStream import CommonTokenStream
+from ..dfa.DFA import DFA
+from ..PredictionContext import PredictionContextCache
+from ..Lexer import Lexer
+from ..atn.LexerATNSimulator import LexerATNSimulator
+from ..ParserRuleContext import ParserRuleContext
+from ..tree.Tree import TerminalNode
 from ..InputStream import InputStream
 from ..Parser import Parser
 from ..RuleContext import RuleContext

omlish/antlr/_runtime/xpath/XPathLexer.py

@@ -2,7 +2,7 @@
 # ruff: noqa
 # flake8: noqa
 # Generated from XPathLexer.g4 by ANTLR 4.11.2-SNAPSHOT
-from .. import *
+from .._all import *
 from io import StringIO
 import sys
 if sys.version_info[1] > 5:

omlish/antlr/delimit.py

@@ -0,0 +1,106 @@
+# ruff: noqa: N802 N815
+import io
+import typing as ta
+
+from .. import check
+from . import runtime as antlr4
+
+
+class DelimitingLexer(antlr4.Lexer):
+    def __init__(
+            self,
+            *args: ta.Any,
+            delimiter_token: ta.Any,
+            delimiters: ta.Iterable[str],
+            no_skip: bool = False,
+            **kwargs,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+
+        self._delimiter_token = delimiter_token
+        self._delimiters = set(check.not_isinstance(delimiters, str))
+        self._no_skip = no_skip
+
+    _hitEOF: bool
+
+    def nextToken(self) -> antlr4.Token:
+        if self._input is None:
+            raise antlr4.IllegalStateException('nextToken requires a non-null input stream.')
+
+        token_start_marker = self._input.mark()
+        try:
+            while True:
+                if self._hitEOF:
+                    self.emitEOF()
+                    return self._token
+
+                self._token: antlr4.Token | None = None
+                self._channel = antlr4.Token.DEFAULT_CHANNEL
+                self._tokenStartCharIndex = self._input.index
+                self._tokenStartColumn = self._interp.column
+                self._tokenStartLine = self._interp.line
+                self._text = None
+
+                continue_outer = False
+                while True:
+                    self._type = antlr4.Token.INVALID_TYPE
+                    ttype = self.SKIP
+
+                    for delimiter in self._delimiters:
+                        if self._match_delimiter(delimiter):
+                            ttype = self._delimiter_token
+                            break
+                    else:
+                        try:
+                            ttype = self._interp.match(self._input, self._mode)
+                        except antlr4.LexerNoViableAltException as e:
+                            self.notifyListeners(e)  # report error
+                            self.recover(e)
+
+                    if self._input.LA(1) == antlr4.Token.EOF:
+                        self._hitEOF = True
+
+                    if self._type == antlr4.Token.INVALID_TYPE:
+                        self._type = ttype
+
+                    if not self._no_skip and self._type == self.SKIP:
+                        continue_outer = True
+                        break
+
+                    if self._type != self.MORE:
+                        break
+
+                if continue_outer:
+                    continue
+
+                if self._token is None:
+                    self.emit()
+
+                return self._token
+
+        finally:
+            self._input.release(token_start_marker)
+
+    def _match_delimiter(self, delimiter: str) -> bool:
+        for i, c in enumerate(delimiter):
+            if chr(self._input.LA(i + 1)) != c:
+                return False
+        self._input.seek(self._input.index + len(delimiter))
+        return True
+
+    def split(self) -> tuple[list[tuple[str, str]], str]:
+        lst = []
+        sb = io.StringIO()
+        while True:
+            token = self.nextToken()
+            if token.type == antlr4.Token.EOF:
+                break
+            if token.type == self._delimiter_token:
+                statement = sb.getvalue().strip()
+                if statement:
+                    lst.append((statement, token.text))
+                sb = io.StringIO()
+            else:
+                sb.write(token.text)
+        partial = sb.getvalue()
+        return lst, partial

omlish/antlr/dot.py

@@ -0,0 +1,31 @@
+from ..graphs import dot
+from . import runtime as antlr4
+from .utils import yield_contexts
+
+
+def dot_ctx(root: antlr4.ParserRuleContext) -> dot.Graph:
+    stmts: list[dot.Stmt] = [
+        dot.RawStmt('rankdir=LR;'),
+    ]
+
+    for c in yield_contexts(root):
+        if isinstance(c, antlr4.TerminalNode):
+            continue
+
+        lbl = [
+            [type(c).__name__],
+            [str(id(c))],
+            [f'{c.start} {c.stop}'],
+        ]
+
+        stmts.append(dot.Node(f'_{id(c)}', {'label': lbl, 'shape': 'box'}))
+
+        for n in (c.children or []):
+            if not isinstance(n, antlr4.TerminalNode):
+                stmts.append(dot.Edge(f'_{id(c)}', f'_{id(n)}'))
+
+    return dot.Graph(stmts)
+
+
+def open_dot_ctx(root: antlr4.ParserRuleContext) -> None:
+    dot.open_dot(dot.render(dot_ctx(root)))

omlish/antlr/errors.py

@@ -0,0 +1,11 @@
+# ruff: noqa: N802 N803
+from . import runtime as antlr4
+
+
+class ParseError(Exception):
+    pass
+
+
+class SilentRaisingErrorListener(antlr4.ErrorListener):
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        raise ParseError(recognizer, offendingSymbol, line, column, msg, e)

omlish/antlr/input.py

@@ -0,0 +1,96 @@
+# ruff: noqa: N802
+import typing as ta
+
+
+##
+
+
+# class InputStream(ta.Protocol):
+#
+#   @property
+#   def index(self) -> int: ...
+#
+#   @property
+#   def size(self) -> int: ...
+#
+#   # Reset the stream so that it's in the same state it was when the object was created *except* the data array is not
+#   # touched.
+#   def reset(self) -> None: ...
+#
+#   def consume(self) -> None: ...
+#
+#   def LA(self, offset: int) -> int: ...
+#
+#   def LT(self, offset: int) -> int: ...
+#
+#   def mark(self) -> int: ...
+#
+#   def release(self, marker: int) -> None: ...
+#
+#   # consume() ahead until p==_index; can't just set p=_index as we must update line and column. If we seek backwards,
+#   # just set p
+#   def seek(self, _index: int) -> None: ...
+#
+#   def getText(self, start: int, stop: int) -> str: ...
+#
+#   def __str__(self) -> str: ...
+
+
+InputStream: ta.TypeAlias = ta.Any
+
+
+##
+
+
+# @lang.protocol_check(InputStream)
+class ProxyInputStream:
+    def __init__(self, target: InputStream) -> None:
+        super().__init__()
+
+        self._target = target
+
+    @property
+    def index(self) -> int:
+        return self._target.index
+
+    @property
+    def size(self) -> int:
+        return self._target.size
+
+    def reset(self) -> None:
+        self._target.reset()
+
+    def consume(self) -> None:
+        self._target.consume()
+
+    def LA(self, offset: int) -> int:
+        return self._target.LA(offset)
+
+    def LT(self, offset: int) -> int:
+        return self._target.LT(offset)
+
+    def mark(self) -> int:
+        return self._target.mark()
+
+    def release(self, marker: int) -> None:
+        return self._target.release(marker)
+
+    def seek(self, _index: int) -> None:
+        return self._target.seek(_index)
+
+    def getText(self, start: int, stop: int) -> str:
+        return self._target.getText(start, stop)
+
+    def __str__(self) -> str:
+        return str(self._target)
+
+
+##
+
+
+class CaseInsensitiveInputStream(ProxyInputStream):
+    def LA(self, offset: int) -> int:
+        ret = super().LA(offset)
+        if ret != -1:
+            ret = ord(chr(ret).upper())
+        return ret

omlish/antlr/parsing.py

@@ -0,0 +1,19 @@
+# ruff: noqa: N802 N803
+import typing as ta
+
+from . import runtime as antlr4
+
+
+LexerT = ta.TypeVar('LexerT', bound=antlr4.Lexer)
+ParserT = ta.TypeVar('ParserT', bound=antlr4.Parser)
+
+
+def parse(
+        buf: str,
+        lexer_cls: type[LexerT],
+        parser_cls: type[ParserT],
+) -> ParserT:
+    lexer = lexer_cls(antlr4.InputStream(buf))
+    stream = antlr4.CommonTokenStream(lexer)
+    stream.fill()
+    return parser_cls(stream)

omlish/antlr/runtime.py

@@ -0,0 +1,102 @@
+# ruff: noqa: I001
+# flake8: noqa: F401
+
+from ._runtime.BufferedTokenStream import (  # type: ignore
+    TokenStream,
+)
+
+from ._runtime.CommonTokenStream import (  # type: ignore
+    CommonTokenStream,
+)
+
+from ._runtime.FileStream import (  # type: ignore
+    FileStream,
+)
+
+from ._runtime.InputStream import (  # type: ignore
+    InputStream,
+)
+
+from ._runtime.Lexer import (  # type: ignore
+    Lexer,
+)
+
+from ._runtime.Parser import (  # type: ignore
+    Parser,
+)
+
+from ._runtime.ParserRuleContext import (  # type: ignore
+    ParserRuleContext,
+    RuleContext,
+)
+
+from ._runtime.PredictionContext import (  # type: ignore
+    PredictionContextCache,
+)
+
+from ._runtime.StdinStream import (  # type: ignore
+    StdinStream,
+)
+
+from ._runtime.Token import (  # type: ignore
+    Token,
+)
+
+from ._runtime.Utils import (  # type: ignore
+    str_list,
+)
+
+from ._runtime.atn.ATN import (  # type: ignore
+    ATN,
+)
+
+from ._runtime.atn.ATNDeserializer import (  # type: ignore
+    ATNDeserializer,
+)
+
+from ._runtime.atn.LexerATNSimulator import (  # type: ignore
+    LexerATNSimulator,
+)
+
+from ._runtime.atn.ParserATNSimulator import (  # type: ignore
+    ParserATNSimulator,
+)
+
+from ._runtime.atn.PredictionMode import (  # type: ignore
+    PredictionMode,
+)
+
+from ._runtime.dfa.DFA import (  # type: ignore
+    DFA,
+)
+
+from ._runtime.error.DiagnosticErrorListener import (  # type: ignore
+    DiagnosticErrorListener,
+)
+
+from ._runtime.error.ErrorListener import (  # type: ignore
+    ErrorListener,
+)
+
+from ._runtime.error.ErrorStrategy import (  # type: ignore
+    BailErrorStrategy,
+)
+
+from ._runtime.error.Errors import (  # type: ignore
+    LexerNoViableAltException,
+)
+
+from ._runtime.error.Errors import (  # type: ignore
+    IllegalStateException,
+    NoViableAltException,
+    RecognitionException,
+)
+
+from ._runtime.tree.Tree import (  # type: ignore
+    ErrorNode,
+    ParseTreeListener,
+    ParseTreeVisitor,
+    ParseTreeWalker,
+    RuleNode,
+    TerminalNode,
+)

omlish/antlr/utils.py

@@ -0,0 +1,38 @@
+# ruff: noqa: N802 N803
+import io
+import typing as ta
+
+from . import runtime as antlr4
+
+
+##
+
+
+def pformat(
+        node: ta.Any,
+        *,
+        buf: ta.IO | None = None,
+        indent: str = '',
+        child_indent: str = '  ',
+) -> ta.IO:
+    if buf is None:
+        buf = io.StringIO()
+    buf.write(indent)
+    buf.write(node.__class__.__name__)
+    if hasattr(node, 'start') and hasattr(node, 'stop'):
+        buf.write(f' ({node.start} -> {node.stop})')
+    buf.write('\n')
+    for child in getattr(node, 'children', []) or []:
+        pformat(child, buf=buf, indent=indent + child_indent, child_indent=child_indent)
+    return buf
+
+
+def yield_contexts(
+        root: antlr4.ParserRuleContext,
+) -> ta.Iterator[antlr4.ParserRuleContext]:
+    q = [root]
+    while q:
+        c = q.pop()
+        yield c
+        if not isinstance(c, antlr4.TerminalNode) and c.children:
+            q.extend(c.children)

{omlish-0.0.0.dev169.dist-info → omlish-0.0.0.dev170.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev169
+Version: 0.0.0.dev170
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev169.dist-info → omlish-0.0.0.dev170.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=0BnQGD2dcXEma0Jop2ZesvDNzSj3CAJBNq8aTGuBz9A,7276
-omlish/__about__.py,sha256=Vbn2IOi3EX8LX5PEfmtAHPOYwizDkndZ2-r_FU5omCw,3409
+omlish/__about__.py,sha256=PoGd-lg7WxO1UiKHGhsCnxmHLiTfBft9-eJMax5A1Vs,3409
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=ubu7lHwss5V4UznbejAI0qXhXahrU01MysuHOZI9C4U,8116
 omlish/cached.py,sha256=UI-XTFBwA6YXWJJJeBn-WkwBkfzDjLBBaZf4nIJA9y0,510
@@ -14,6 +14,13 @@ omlish/subprocesses.py,sha256=n6pk0nUaTFHzD_A6duyKNJ4ggncU7uNepfh_T90etHE,8671
 omlish/sync.py,sha256=QJ79kxmIqDP9SeHDoZAf--DpFIhDQe1jACy8H4N0yZI,2928
 omlish/term.py,sha256=EVHm3lEEIc9hT4f8BPmzbNUwlqZ8nrRpCwyQMN7LBm0,9313
 omlish/antlr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omlish/antlr/delimit.py,sha256=3Byvh9_Ip8ftM_SeSEmMbnNo1jrxk-xm8HnHDp_nDaI,3466
+omlish/antlr/dot.py,sha256=uH2X7-8xNLYDQNJ30uW8ssv1MLkZSm07GsalcRuunYI,817
+omlish/antlr/errors.py,sha256=foYz2109WReT1C7qZsIrb4zCAkZg4vM_UiDOAPC0AqQ,308
+omlish/antlr/input.py,sha256=baeO279AIxR50pymya0eabtnc2A0bSdA5u7jvIGebzA,2090
+omlish/antlr/parsing.py,sha256=PH4WlQAqr6ZfnOUNeQLaTMaJJjx3vK2TCgI9HQUNAKk,435
+omlish/antlr/runtime.py,sha256=wYUiJ0qoj4soHFL6fsq91MnUrDSKUEQVmJScKJibOAc,1975
+omlish/antlr/utils.py,sha256=hi_RFUl222r2gQsmmm5MYg5_vYa3q8u-KP4CC1ZHndA,912
 omlish/antlr/_runtime/BufferedTokenStream.py,sha256=1Rnhm62MZCWSuQeRs7lRUbdtdyo7Gyg8r4gAETjv-cE,10793
 omlish/antlr/_runtime/CommonTokenFactory.py,sha256=QrSSTH0gYhOpPeOHqrs6-2g1PGcgYvjhR6J6pynKLOc,2147
 omlish/antlr/_runtime/CommonTokenStream.py,sha256=L7giynpsS97oM6ZtPRIw8m6eIbGSaeEUJ7HN6b2etN4,2795
@@ -34,7 +41,8 @@ omlish/antlr/_runtime/StdinStream.py,sha256=8up7-oFlr-ydpFV7kFqI1mRDD83Y8wYcXs0r
 omlish/antlr/_runtime/Token.py,sha256=Ywq-AwJz6GXQ431TTFExNylshQbNr6T5u4_48dxlrtk,5249
 omlish/antlr/_runtime/TokenStreamRewriter.py,sha256=2Zd8vdNQ7_XF1Y4r3axxHTD-hdauxyEPaePOqArF1g0,10355
 omlish/antlr/_runtime/Utils.py,sha256=Edv360609RwDaEz2JxlXCj9-HuXNEmqr4RVVcbhdLco,974
-omlish/antlr/_runtime/__init__.py,sha256=i-TtI82yr2C7owc6_T7nYULFvULcwJ9wSVbq3p71DgY,1042
+omlish/antlr/_runtime/__init__.py,sha256=Jn5lqTVbeUQXD5a4IxDHKibOatAQWVTlaQ8M4mYu2Yw,28
+omlish/antlr/_runtime/_all.py,sha256=MbNYoQYRympa1nGlgtuZ1AkJTv1SacqvBKG7bTXG0So,1042
 omlish/antlr/_runtime/_pygrun.py,sha256=22tgQKyhLO2UbnwacAzsew7bkXjENctDs4XrmSHAqXc,6328
 omlish/antlr/_runtime/atn/ATN.py,sha256=0V07bHRY-_rX-Du85F08KbMDbvr055co3Crt0VZbwOo,5792
 omlish/antlr/_runtime/atn/ATNConfig.py,sha256=sY7zO2oSh9SLSvs05gY84vtFmV4ZcTKz7dXvDIxH_ew,6573
@@ -47,16 +55,16 @@ omlish/antlr/_runtime/atn/ATNType.py,sha256=_UdEWJXYM9gmOQ0u8XxruKLJTYU5ePuNGMAQ
 omlish/antlr/_runtime/atn/LexerATNSimulator.py,sha256=ZFUTqu7D39AiC8VZunslTrsl7sZKpukEzlkWFK8CRBA,25408
 omlish/antlr/_runtime/atn/LexerAction.py,sha256=PS8ArQadDRVXYnfCbOxJBuEVh7jMX2JtarhxZJ9c-jE,10057
 omlish/antlr/_runtime/atn/LexerActionExecutor.py,sha256=GoLnxIG-mzOAHLZvfgIBMGB9i2FyXrZrqtFK3B0Hoak,6448
-omlish/antlr/_runtime/atn/ParserATNSimulator.py,sha256=f88xNWRRsMSUz7Nf4oX-MQ9HTMdl0zBK7RcraKWZZlE,80739
+omlish/antlr/_runtime/atn/ParserATNSimulator.py,sha256=5N0htVWAy3x8rfWVs1YN2Jz16LLpXKjAwefFPXgBHcM,80746
 omlish/antlr/_runtime/atn/PredictionMode.py,sha256=JAnsYHfd6vD1t1wvLNpBuyi5avjxn8Flbkh_lcrgs1g,22479
 omlish/antlr/_runtime/atn/SemanticContext.py,sha256=jYz90ZjiL4Hcya5881fTQd3zvTzTYpjsntiqiRx7xLA,10674
 omlish/antlr/_runtime/atn/Transition.py,sha256=YrPBbwKK9E4SwFNmS5u6ATfZ-uC-fx5GSAtPyQsBn4E,8775
 omlish/antlr/_runtime/atn/__init__.py,sha256=lMd_BbXYdlDhZQN_q0TKN978XW5G0pq618F0NaLkpFE,71
 omlish/antlr/_runtime/dfa/DFA.py,sha256=1eLI8ckM7_Q4dx_l5m1eiiqJPpaTWJ1DDKUMUUbc-qA,5381
-omlish/antlr/_runtime/dfa/DFASerializer.py,sha256=_adTLo6rq6qJqDATZ3s2mTMqLXuaSQeNsHQfYAH8a-A,2542
+omlish/antlr/_runtime/dfa/DFASerializer.py,sha256=HmQpIrVl0_kit8GSCqYyT4AnFvWyBj8vuye0YeFNEKE,2549
 omlish/antlr/_runtime/dfa/DFAState.py,sha256=vZ5sBJc0hp5BaOVVT3sdQEd1jEi6yb-u-aO9DHpC2Tw,5616
 omlish/antlr/_runtime/dfa/__init__.py,sha256=lMd_BbXYdlDhZQN_q0TKN978XW5G0pq618F0NaLkpFE,71
-omlish/antlr/_runtime/error/DiagnosticErrorListener.py,sha256=Jnzwgij80-xjj54GR2YYsC6QubSEp9RuWnw2fH9a6tU,4452
+omlish/antlr/_runtime/error/DiagnosticErrorListener.py,sha256=SyUCrVs2Vzgvf8j2cSkzjODRBeXrVVrKytRH2LxjALs,4479
 omlish/antlr/_runtime/error/ErrorListener.py,sha256=pPVVFGIDbELkMhG-A5-b39y3SkNkJvsP6n8Y0TfotfA,2765
 omlish/antlr/_runtime/error/ErrorStrategy.py,sha256=0nZwpqR8L0264DphJHoEmYkQHlxZxCEdO54RAvHY6FI,30407
 omlish/antlr/_runtime/error/Errors.py,sha256=sCf-5-vb9MyO8XIDdHSqV_ozfEcRrm87yjg_sNtStXM,6808
@@ -70,8 +78,8 @@ omlish/antlr/_runtime/tree/TokenTagToken.py,sha256=V2ymw3sTiykgi7Lp64a7VsW_s8Lvx
 omlish/antlr/_runtime/tree/Tree.py,sha256=-5aYTkO_eUUGY2BPY03IJLyG72lNMeO_uuf2u1kZL_4,5610
 omlish/antlr/_runtime/tree/Trees.py,sha256=iRcq2bhjBziXEUr6OFFs1rJs82q6wXTSduSBfCMMG7k,3985
 omlish/antlr/_runtime/tree/__init__.py,sha256=Jn5lqTVbeUQXD5a4IxDHKibOatAQWVTlaQ8M4mYu2Yw,28
-omlish/antlr/_runtime/xpath/XPath.py,sha256=CbS0Fpnd2aRt_nQUBJlTpoHpxCyT9qbVW8ldj1aQJKY,9643
-omlish/antlr/_runtime/xpath/XPathLexer.py,sha256=xFtdr4ZXMZxb2dnB_ggWyhvlQiC7RXQlDS5ePhTyOGg,3505
+omlish/antlr/_runtime/xpath/XPath.py,sha256=KSL1SH3VAeRDZCe4dAD7xmUdfk-j434ypZKRreFG2vk,9820
+omlish/antlr/_runtime/xpath/XPathLexer.py,sha256=WvGKQjQnu7pX5C4CFKtsCzba2B2W6ie4ivtWLvlgymM,3509
 omlish/antlr/_runtime/xpath/__init__.py,sha256=lMd_BbXYdlDhZQN_q0TKN978XW5G0pq618F0NaLkpFE,71
 omlish/argparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse/all.py,sha256=EfUSf27vFWqa4Q93AycU5YRsrHt-Nx3pU3uNVapb-EE,1054
@@ -559,9 +567,9 @@ omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,329
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
 omlish/text/random.py,sha256=jNWpqiaKjKyTdMXC-pWAsSC10AAP-cmRRPVhm59ZWLk,194
-omlish-0.0.0.dev169.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev169.dist-info/METADATA,sha256=CsUpWiDs5ax6CJfLmh_ssyLkwhwgoju6FMPzic0v_58,4264
-omlish-0.0.0.dev169.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-omlish-0.0.0.dev169.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev169.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev169.dist-info/RECORD,,
+omlish-0.0.0.dev170.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev170.dist-info/METADATA,sha256=1zURRBI9Xgzn95Gk7PvYo_f_QCqUBqd_uNIFZZVBuHM,4264
+omlish-0.0.0.dev170.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+omlish-0.0.0.dev170.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev170.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev170.dist-info/RECORD,,