omlish 0.0.0.dev57__py3-none-any.whl → 0.0.0.dev58__py3-none-any.whl

omlish/antlr/_runtime/tree/Trees.py

@@ -0,0 +1,114 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+
+# A set of utility routines useful for all kinds of ANTLR trees.#
+from io import StringIO
+from ..Token import Token
+from ..Utils import escapeWhitespace
+from .Tree import RuleNode, ErrorNode, TerminalNode, Tree, ParseTree
+
+# need forward declaration
+Parser  = None
+
+class Trees(object):
+
+     # Print out a whole tree in LISP form. {@link #getNodeText} is used on the
+    #  node payloads to get the text for the nodes.  Detect
+    #  parse trees and extract data appropriately.
+    @classmethod
+    def toStringTree(cls, t:Tree, ruleNames:list=None, recog:Parser=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        s = escapeWhitespace(cls.getNodeText(t, ruleNames), False)
+        if t.getChildCount()==0:
+            return s
+        with StringIO() as buf:
+            buf.write("(")
+            buf.write(s)
+            buf.write(' ')
+            for i in range(0, t.getChildCount()):
+                if i > 0:
+                    buf.write(' ')
+                buf.write(cls.toStringTree(t.getChild(i), ruleNames))
+            buf.write(")")
+            return buf.getvalue()
+
+    @classmethod
+    def getNodeText(cls, t:Tree, ruleNames:list=None, recog:Parser=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        if ruleNames is not None:
+            if isinstance(t, RuleNode):
+                if t.getAltNumber()!=0: # should use ATN.INVALID_ALT_NUMBER but won't compile
+                    return ruleNames[t.getRuleIndex()]+":"+str(t.getAltNumber())
+                return ruleNames[t.getRuleIndex()]
+            elif isinstance( t, ErrorNode):
+                return str(t)
+            elif isinstance(t, TerminalNode):
+                if t.symbol is not None:
+                    return t.symbol.text
+        # no recog for rule names
+        payload = t.getPayload()
+        if isinstance(payload, Token ):
+            return payload.text
+        return str(t.getPayload())
+
+
+    # Return ordered list of all children of this node
+    @classmethod
+    def getChildren(cls, t:Tree):
+        return [ t.getChild(i) for i in range(0, t.getChildCount()) ]
+
+    # Return a list of all ancestors of this node.  The first node of
+    #  list is the root and the last is the parent of this node.
+    #
+    @classmethod
+    def getAncestors(cls, t:Tree):
+        ancestors = []
+        t = t.getParent()
+        while t is not None:
+            ancestors.insert(0, t) # insert at start
+            t = t.getParent()
+        return ancestors
+
+    @classmethod
+    def findAllTokenNodes(cls, t:ParseTree, ttype:int):
+        return cls.findAllNodes(t, ttype, True)
+
+    @classmethod
+    def findAllRuleNodes(cls, t:ParseTree, ruleIndex:int):
+        return cls.findAllNodes(t, ruleIndex, False)
+
+    @classmethod
+    def findAllNodes(cls, t:ParseTree, index:int, findTokens:bool):
+        nodes = []
+        cls._findAllNodes(t, index, findTokens, nodes)
+        return nodes
+
+    @classmethod
+    def _findAllNodes(cls, t:ParseTree, index:int, findTokens:bool, nodes:list):
+        from ..ParserRuleContext import ParserRuleContext
+        # check this node (the root) first
+        if findTokens and isinstance(t, TerminalNode):
+            if t.symbol.type==index:
+                nodes.append(t)
+        elif not findTokens and isinstance(t, ParserRuleContext):
+            if t.ruleIndex == index:
+                nodes.append(t)
+        # check children
+        for i in range(0, t.getChildCount()):
+            cls._findAllNodes(t.getChild(i), index, findTokens, nodes)
+
+    @classmethod
+    def descendants(cls, t:ParseTree):
+        nodes = [t]
+        for i in range(0, t.getChildCount()):
+            nodes.extend(cls.descendants(t.getChild(i)))
+        return nodes

omlish/antlr/_runtime/tree/__init__.py

@@ -0,0 +1,2 @@
+# ruff: noqa
+# flake8: noqa

omlish/antlr/_runtime/xpath/XPath.py

@@ -0,0 +1,272 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# Represent a subset of XPath XML path syntax for use in identifying nodes in
+# parse trees.
+#
+# <p>
+# Split path into words and separators {@code /} and {@code //} via ANTLR
+# itself then walk path elements from left to right. At each separator-word
+# pair, find set of nodes. Next stage uses those as work list.</p>
+#
+# <p>
+# The basic interface is
+# {@link XPath#findAll ParseTree.findAll}{@code (tree, pathString, parser)}.
+# But that is just shorthand for:</p>
+#
+# <pre>
+# {@link XPath} p = new {@link XPath#XPath XPath}(parser, pathString);
+# return p.{@link #evaluate evaluate}(tree);
+# </pre>
+#
+# <p>
+# See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this
+# allows operators:</p>
+#
+# <dl>
+# <dt>/</dt> <dd>root</dd>
+# <dt>//</dt> <dd>anywhere</dd>
+# <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
+# operator</dd>
+# </dl>
+#
+# <p>
+# and path elements:</p>
+#
+# <dl>
+# <dt>ID</dt> <dd>token name</dd>
+# <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
+# <dt>expr</dt> <dd>rule name</dd>
+# <dt>*</dt> <dd>wildcard matching any node</dd>
+# </dl>
+#
+# <p>
+# Whitespace is not allowed.</p>
+#
+from .. import CommonTokenStream, DFA, PredictionContextCache, Lexer, LexerATNSimulator, ParserRuleContext, TerminalNode
+from ..InputStream import InputStream
+from ..Parser import Parser
+from ..RuleContext import RuleContext
+from ..Token import Token
+from ..atn.ATNDeserializer import ATNDeserializer
+from ..error.ErrorListener import ErrorListener
+from ..error.Errors import LexerNoViableAltException
+from ..tree.Tree import ParseTree
+from ..tree.Trees import Trees
+from io import StringIO
+from .XPathLexer import XPathLexer
+
+
+class XPath(object):
+
+    WILDCARD = "*" # word not operator/separator
+    NOT = "!" # word for invert operator
+
+    def __init__(self, parser:Parser, path:str):
+        self.parser = parser
+        self.path = path
+        self.elements = self.split(path)
+
+    def split(self, path:str):
+        input = InputStream(path)
+        lexer = XPathLexer(input)
+        def recover(self, e):
+            raise e
+        lexer.recover = recover
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(ErrorListener()) # XPathErrorListener does no more
+        tokenStream = CommonTokenStream(lexer)
+        try:
+            tokenStream.fill()
+        except LexerNoViableAltException as e:
+            pos = lexer.column
+            msg = "Invalid tokens or characters at index %d in path '%s'" % (pos, path)
+            raise Exception(msg, e)
+
+        tokens = iter(tokenStream.tokens)
+        elements = list()
+        for el in tokens:
+            invert = False
+            anywhere = False
+            # Check for path separators, if none assume root
+            if el.type in [XPathLexer.ROOT, XPathLexer.ANYWHERE]:
+                anywhere = el.type == XPathLexer.ANYWHERE
+                next_el = next(tokens, None)
+                if not next_el:
+                    raise Exception('Missing element after %s' % el.getText())
+                else:
+                    el = next_el
+            # Check for bangs
+            if el.type == XPathLexer.BANG:
+                invert = True
+                next_el = next(tokens, None)
+                if not next_el:
+                    raise Exception('Missing element after %s' % el.getText())
+                else:
+                    el = next_el
+            # Add searched element
+            if el.type in [XPathLexer.TOKEN_REF, XPathLexer.RULE_REF, XPathLexer.WILDCARD, XPathLexer.STRING]:
+                element = self.getXPathElement(el, anywhere)
+                element.invert = invert
+                elements.append(element)
+            elif el.type==Token.EOF:
+                break
+            else:
+                raise Exception("Unknown path element %s" % lexer.symbolicNames[el.type])
+        return elements
+
+    #
+    # Convert word like {@code#} or {@code ID} or {@code expr} to a path
+    # element. {@code anywhere} is {@code true} if {@code //} precedes the
+    # word.
+    #
+    def getXPathElement(self, wordToken:Token, anywhere:bool):
+        if wordToken.type==Token.EOF:
+            raise Exception("Missing path element at end of path")
+
+        word = wordToken.text
+        if wordToken.type==XPathLexer.WILDCARD :
+            return XPathWildcardAnywhereElement() if anywhere else XPathWildcardElement()
+
+        elif wordToken.type in [XPathLexer.TOKEN_REF, XPathLexer.STRING]:
+            tsource = self.parser.getTokenStream().tokenSource
+
+            ttype = Token.INVALID_TYPE
+            if wordToken.type == XPathLexer.TOKEN_REF:
+                if word in tsource.ruleNames:
+                    ttype = tsource.ruleNames.index(word) + 1
+            else:
+                if word in tsource.literalNames:
+                    ttype = tsource.literalNames.index(word)
+
+            if ttype == Token.INVALID_TYPE:
+                raise Exception("%s at index %d isn't a valid token name" % (word, wordToken.tokenIndex))
+            return XPathTokenAnywhereElement(word, ttype) if anywhere else XPathTokenElement(word, ttype)
+
+        else:
+            ruleIndex = self.parser.ruleNames.index(word) if word in self.parser.ruleNames else -1
+
+            if ruleIndex == -1:
+                raise Exception("%s at index %d isn't a valid rule name" % (word, wordToken.tokenIndex))
+            return XPathRuleAnywhereElement(word, ruleIndex) if anywhere else XPathRuleElement(word, ruleIndex)
+
+
+    @staticmethod
+    def findAll(tree:ParseTree, xpath:str, parser:Parser):
+        p = XPath(parser, xpath)
+        return p.evaluate(tree)
+
+    #
+    # Return a list of all nodes starting at {@code t} as root that satisfy the
+    # path. The root {@code /} is relative to the node passed to
+    # {@link #evaluate}.
+    #
+    def evaluate(self, t:ParseTree):
+        dummyRoot = ParserRuleContext()
+        dummyRoot.children = [t] # don't set t's parent.
+
+        work = [dummyRoot]
+        for element in self.elements:
+            work_next = list()
+            for node in work:
+                if not isinstance(node, TerminalNode) and node.children:
+                    # only try to match next element if it has children
+                    # e.g., //func/*/stat might have a token node for which
+                    # we can't go looking for stat nodes.
+                    matching = element.evaluate(node)
+
+                    # See issue antlr#370 - Prevents XPath from returning the
+                    # same node multiple times
+                    matching = filter(lambda m: m not in work_next, matching)
+
+                    work_next.extend(matching)
+            work = work_next
+
+        return work
+
+
+class XPathElement(object):
+
+    def __init__(self, nodeName:str):
+        self.nodeName = nodeName
+        self.invert = False
+
+    def __str__(self):
+        return type(self).__name__ + "[" + ("!" if self.invert else "") + self.nodeName + "]"
+
+
+
+#
+# Either {@code ID} at start of path or {@code ...//ID} in middle of path.
+#
+class XPathRuleAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName:str, ruleIndex:int):
+        super().__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t:ParseTree):
+        # return all ParserRuleContext descendants of t that match ruleIndex (or do not match if inverted)
+        return filter(lambda c: isinstance(c, ParserRuleContext) and (self.invert ^ (c.getRuleIndex() == self.ruleIndex)), Trees.descendants(t))
+
+class XPathRuleElement(XPathElement):
+
+    def __init__(self, ruleName:str, ruleIndex:int):
+        super().__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t:ParseTree):
+        # return all ParserRuleContext children of t that match ruleIndex (or do not match if inverted)
+        return filter(lambda c: isinstance(c, ParserRuleContext) and (self.invert ^ (c.getRuleIndex() == self.ruleIndex)), Trees.getChildren(t))
+
+class XPathTokenAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName:str, tokenType:int):
+        super().__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t:ParseTree):
+        # return all TerminalNode descendants of t that match tokenType (or do not match if inverted)
+        return filter(lambda c: isinstance(c, TerminalNode) and (self.invert ^ (c.symbol.type == self.tokenType)), Trees.descendants(t))
+
+class XPathTokenElement(XPathElement):
+
+    def __init__(self, ruleName:str, tokenType:int):
+        super().__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t:ParseTree):
+        # return all TerminalNode children of t that match tokenType (or do not match if inverted)
+        return filter(lambda c: isinstance(c, TerminalNode) and (self.invert ^ (c.symbol.type == self.tokenType)), Trees.getChildren(t))
+
+
+class XPathWildcardAnywhereElement(XPathElement):
+
+    def __init__(self):
+        super().__init__(XPath.WILDCARD)
+
+    def evaluate(self, t:ParseTree):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.descendants(t)
+
+
+class XPathWildcardElement(XPathElement):
+
+    def __init__(self):
+        super().__init__(XPath.WILDCARD)
+
+
+    def evaluate(self, t:ParseTree):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.getChildren(t)

omlish/antlr/_runtime/xpath/XPathLexer.py

@@ -0,0 +1,98 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+# Generated from XPathLexer.g4 by ANTLR 4.11.2-SNAPSHOT
+from .. import *
+from io import StringIO
+import sys
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+def serializedATN():
+    return [
+        4,0,8,50,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,
+        6,7,6,2,7,7,7,1,0,1,0,1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,4,1,4,5,4,29,
+        8,4,10,4,12,4,32,9,4,1,4,1,4,1,5,1,5,3,5,38,8,5,1,6,1,6,1,7,1,7,
+        5,7,44,8,7,10,7,12,7,47,9,7,1,7,1,7,1,45,0,8,1,3,3,4,5,5,7,6,9,7,
+        11,0,13,0,15,8,1,0,2,5,0,48,57,95,95,183,183,768,879,8255,8256,13,
+        0,65,90,97,122,192,214,216,246,248,767,880,893,895,8191,8204,8205,
+        8304,8591,11264,12271,12289,55295,63744,64975,65008,65533,50,0,1,
+        1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,15,1,0,
+        0,0,1,17,1,0,0,0,3,20,1,0,0,0,5,22,1,0,0,0,7,24,1,0,0,0,9,26,1,0,
+        0,0,11,37,1,0,0,0,13,39,1,0,0,0,15,41,1,0,0,0,17,18,5,47,0,0,18,
+        19,5,47,0,0,19,2,1,0,0,0,20,21,5,47,0,0,21,4,1,0,0,0,22,23,5,42,
+        0,0,23,6,1,0,0,0,24,25,5,33,0,0,25,8,1,0,0,0,26,30,3,13,6,0,27,29,
+        3,11,5,0,28,27,1,0,0,0,29,32,1,0,0,0,30,28,1,0,0,0,30,31,1,0,0,0,
+        31,33,1,0,0,0,32,30,1,0,0,0,33,34,6,4,0,0,34,10,1,0,0,0,35,38,3,
+        13,6,0,36,38,7,0,0,0,37,35,1,0,0,0,37,36,1,0,0,0,38,12,1,0,0,0,39,
+        40,7,1,0,0,40,14,1,0,0,0,41,45,5,39,0,0,42,44,9,0,0,0,43,42,1,0,
+        0,0,44,47,1,0,0,0,45,46,1,0,0,0,45,43,1,0,0,0,46,48,1,0,0,0,47,45,
+        1,0,0,0,48,49,5,39,0,0,49,16,1,0,0,0,4,0,30,37,45,1,1,4,0
+    ]
+
+class XPathLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+    TOKEN_REF = 1
+    RULE_REF = 2
+    ANYWHERE = 3
+    ROOT = 4
+    WILDCARD = 5
+    BANG = 6
+    ID = 7
+    STRING = 8
+
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'//'", "'/'", "'*'", "'!'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "TOKEN_REF", "RULE_REF", "ANYWHERE", "ROOT", "WILDCARD", "BANG", 
+            "ID", "STRING" ]
+
+    ruleNames = [ "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID", "NameChar", 
+                  "NameStartChar", "STRING" ]
+
+    grammarFileName = "XPathLexer.g4"
+
+    def __init__(self, input=None, output:TextIO = sys.stdout):
+        super().__init__(input, output)
+        self.checkVersion("4.11.2-SNAPSHOT")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+
+    def action(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+        if self._actions is None:
+            actions = dict()
+            actions[4] = self.ID_action 
+            self._actions = actions
+        action = self._actions.get(ruleIndex, None)
+        if action is not None:
+            action(localctx, actionIndex)
+        else:
+            raise Exception("No registered action for:" + str(ruleIndex))
+
+
+    def ID_action(self, localctx:RuleContext , actionIndex:int):
+        if actionIndex == 0:
+
+                            char = self.text[0]
+                            if char.isupper():
+                                self.type = XPathLexer.TOKEN_REF
+                            else:
+                                self.type = XPathLexer.RULE_REF
+            				
+     
+
+

omlish/antlr/_runtime/xpath/__init__.py

@@ -0,0 +1,4 @@
+# type: ignore
+# ruff: noqa
+# flake8: noqa
+__author__ = 'ericvergnaud'

{omlish-0.0.0.dev57.dist-info → omlish-0.0.0.dev58.dist-info}/METADATA

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

{omlish-0.0.0.dev57.dist-info → omlish-0.0.0.dev58.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=wTGXwNmvtaKsDWtTwwj3Uib5Inaj8ZBn0MB69bE80X4,1419
-omlish/__about__.py,sha256=TcVGEzTkX3fMqsIJaOXPCs013BBL_Tc4-lqbwNV4bgs,3420
+omlish/__about__.py,sha256=9Lm5v-nFcGeCoABbD4--4eapTUaI4C0188gIFKvfBzI,3420
 omlish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/argparse.py,sha256=Vr70_85EVLJLgEkRtwOr264tMRtqtlN7ncFfXRUk5aM,6914
 omlish/c3.py,sha256=4vogWgwPb8TbNS2KkZxpoWbwjj7MuHG2lQG-hdtkvjI,8062
@@ -19,6 +19,65 @@ omlish/os.py,sha256=vO1sZCzAhVxo46tDFLrD52q2KuMFWQwu5MPJgSsnliI,3107
 omlish/runmodule.py,sha256=PWvuAaJ9wQQn6bx9ftEL3_d04DyotNn8dR_twm2pgw0,700
 omlish/sync.py,sha256=AqwIfIuCMVHLwlJUa7dmaSjfA4sM5AYPCD5-nsz3XVQ,1516
 omlish/term.py,sha256=NEmxqAhicyInGtmFamZAizI2xdu819MzFYPEp0Fx97M,6111
+omlish/antlr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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
+omlish/antlr/_runtime/FileStream.py,sha256=X2PqkNatRxhFrk3acH4NhWv0aBCgMwAn87pmrTLmL5c,905
+omlish/antlr/_runtime/InputStream.py,sha256=50Ko4Vq-iWpk7sAMhJ0rrmB3LFv20TztUMpeIEcEfxg,2371
+omlish/antlr/_runtime/IntervalSet.py,sha256=-8puC1vhHPwFMG3YzmA62MjJf37hkBSzteJ_GIvXJhk,6002
+omlish/antlr/_runtime/LL1Analyzer.py,sha256=Try7EBMnZfpDV-E_JDCTluc9XnbTPfNanDvVYtAUxzE,7747
+omlish/antlr/_runtime/Lexer.py,sha256=p5BbDve_V7Oms9FiiNfbVWWXc6dwt5B9wqije-RUc_0,11549
+omlish/antlr/_runtime/ListTokenSource.py,sha256=wjaO4eWaZu5LTHFlNGnaW4K8kfuPW28wVbRkyElYjD0,5381
+omlish/antlr/_runtime/Parser.py,sha256=RClLh37vtzhOpopUZPvSEesfya5yyC3Acpo1Bqzs1JM,22842
+omlish/antlr/_runtime/ParserInterpreter.py,sha256=F0Uscv8hApF7Z4Nm8sE9naGhJrn6tlix7BRcANOvpp8,7177
+omlish/antlr/_runtime/ParserRuleContext.py,sha256=2iV0H6_tjBD6LIQh8wMRlpZ4cSNxNc1_8MSeJUcdj7s,6787
+omlish/antlr/_runtime/PredictionContext.py,sha256=WWtD-vG0KcBtKqyjt42lGprSuu-VfSixeNxxbi8rQtw,23516
+omlish/antlr/_runtime/Recognizer.py,sha256=wsI9wHVeFk0b7J4E8dutGTX_B_U9lELoiTdoirQR29s,5397
+omlish/antlr/_runtime/RuleContext.py,sha256=tKXuP56if7CObxGkliLFynf8Da42Nr2CejFhReFK56g,8130
+omlish/antlr/_runtime/StdinStream.py,sha256=8up7-oFlr-ydpFV7kFqI1mRDD83Y8wYcXs0rBj-73Us,340
+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/_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
+omlish/antlr/_runtime/atn/ATNConfigSet.py,sha256=vm06ECB3eJsD7BssUCoi08FAsnpRnJJDeuMZKMrlDNc,8336
+omlish/antlr/_runtime/atn/ATNDeserializationOptions.py,sha256=87uY6moHi9KpjeRZxwGLsaUL4eNZabFLL9nEK9m-WxU,1053
+omlish/antlr/_runtime/atn/ATNDeserializer.py,sha256=TwMeggclcky9tlmAmUXEilBfp2GMIFyveJGOYai-h5Q,18938
+omlish/antlr/_runtime/atn/ATNSimulator.py,sha256=RCQsNhVBbY0tdShJYJ7m5jhbcAWPsLe1PnasrJ4owos,2311
+omlish/antlr/_runtime/atn/ATNState.py,sha256=Eq2l1BLDqtZG8VHmoDCEUnyeiRJ-hcWPrzE5Kh_MY9w,7696
+omlish/antlr/_runtime/atn/ATNType.py,sha256=_UdEWJXYM9gmOQ0u8XxruKLJTYU5ePuNGMAQQu1mWv4,465
+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/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/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/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
+omlish/antlr/_runtime/error/__init__.py,sha256=lMd_BbXYdlDhZQN_q0TKN978XW5G0pq618F0NaLkpFE,71
+omlish/antlr/_runtime/tree/Chunk.py,sha256=xsSnPUGcULkNDJNLlpqq1tqwa2WhsgH-K1JOfKRI3_A,738
+omlish/antlr/_runtime/tree/ParseTreeMatch.py,sha256=sKf5rCZK7NosjIWIMjb7DtgobDfOa1k5sXNrm43dwRE,4506
+omlish/antlr/_runtime/tree/ParseTreePattern.py,sha256=TUpGiMTK2_qZO77f0Qa_rZidJa9IiBLoXOTjbmgwH7o,2851
+omlish/antlr/_runtime/tree/ParseTreePatternMatcher.py,sha256=EzOgoX-2sp1Gxsls8AVqiT20RbslFkt5kYuNayj-czY,16320
+omlish/antlr/_runtime/tree/RuleTagToken.py,sha256=KB4A0yYRSoYLOoPZNQogi2uU9IriMr8aiY668wB-6dg,2060
+omlish/antlr/_runtime/tree/TokenTagToken.py,sha256=V2ymw3sTiykgi7Lp64a7VsW_s8LvxAQ2FiHd5aOJPhA,1614
+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/__init__.py,sha256=lMd_BbXYdlDhZQN_q0TKN978XW5G0pq618F0NaLkpFE,71
 omlish/asyncs/__init__.py,sha256=uUz9ziKh4_QrgmdhKFMgq6j7mFbiZd3LiogguDCQsGI,587
 omlish/asyncs/anyio.py,sha256=gfpx-D8QGmUfhnQxHEaHXcAP8zSMQjcGw4COFTGNnHI,8021
 omlish/asyncs/asyncio.py,sha256=JfM59QgB3asgEbrps0zoVbNjWD4kL2XdsEkRMEIoFos,971
@@ -347,9 +406,9 @@ omlish/text/delimit.py,sha256=ubPXcXQmtbOVrUsNh5gH1mDq5H-n1y2R4cPL5_DQf68,4928
 omlish/text/glyphsplit.py,sha256=Ug-dPRO7x-OrNNr8g1y6DotSZ2KH0S-VcOmUobwa4B0,3296
 omlish/text/indent.py,sha256=6Jj6TFY9unaPa4xPzrnZemJ-fHsV53IamP93XGjSUHs,1274
 omlish/text/parts.py,sha256=7vPF1aTZdvLVYJ4EwBZVzRSy8XB3YqPd7JwEnNGGAOo,6495
-omlish-0.0.0.dev57.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev57.dist-info/METADATA,sha256=SSyQEUrMKl0Bkig1soCu8_V7T-AVM8weCHYyMkDp8bc,4167
-omlish-0.0.0.dev57.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-omlish-0.0.0.dev57.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev57.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev57.dist-info/RECORD,,
+omlish-0.0.0.dev58.dist-info/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev58.dist-info/METADATA,sha256=-icqkrn-C-DS9CnevAt4nCKPYw1Jtihk9afU-2S7w3Q,4167
+omlish-0.0.0.dev58.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+omlish-0.0.0.dev58.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev58.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev58.dist-info/RECORD,,