jaclang 0.5.10__py3-none-any.whl → 0.5.15__py3-none-any.whl

jaclang/compiler/generated/jac_parser.py

@@ -0,0 +1,4069 @@
+# The file was automatically generated by Lark v1.1.9
+__version__ = "1.1.9"
+
+#
+#
+#   Lark Stand-alone Generator Tool
+# ----------------------------------
+# Generates a stand-alone LALR(1) parser
+#
+# Git:    https://github.com/erezsh/lark
+# Author: Erez Shinan (erezshin@gmail.com)
+#
+#
+#    >>> LICENSE
+#
+#    This tool and its generated code use a separate license from Lark,
+#    and are subject to the terms of the Mozilla Public License, v. 2.0.
+#    If a copy of the MPL was not distributed with this
+#    file, You can obtain one at https://mozilla.org/MPL/2.0/.
+#
+#    If you wish to purchase a commercial license for this tool and its
+#    generated code, you may contact me via email or otherwise.
+#
+#    If MPL2 is incompatible with your free or open-source project,
+#    contact me and we'll work it out.
+#
+#
+
+from copy import deepcopy
+from abc import ABC, abstractmethod
+from types import ModuleType
+from typing import (
+    TypeVar,
+    Generic,
+    Type,
+    Tuple,
+    List,
+    Dict,
+    Iterator,
+    Collection,
+    Callable,
+    Optional,
+    FrozenSet,
+    Any,
+    Union,
+    Iterable,
+    IO,
+    TYPE_CHECKING,
+    overload,
+    Sequence,
+    Pattern as REPattern,
+    ClassVar,
+    Set,
+    Mapping,
+)
+
+
+
+
+class LarkError(Exception):
+    pass
+
+
+class ConfigurationError(LarkError, ValueError):
+    pass
+
+
+def assert_config(value, options: Collection, msg="Got %r, expected one of %s"):
+    if value not in options:
+        raise ConfigurationError(msg % (value, options))
+
+
+class GrammarError(LarkError):
+    pass
+
+
+class ParseError(LarkError):
+    pass
+
+
+class LexError(LarkError):
+    pass
+
+
+T = TypeVar("T")
+
+
+class UnexpectedInput(LarkError):
+    #--
+
+    line: int
+    column: int
+    pos_in_stream = None
+    state: Any
+    _terminals_by_name = None
+    interactive_parser: "InteractiveParser"
+
+    def get_context(self, text: str, span: int = 40) -> str:
+        #--
+        assert self.pos_in_stream is not None, self
+        pos = self.pos_in_stream
+        start = max(pos - span, 0)
+        end = pos + span
+        if not isinstance(text, bytes):
+            before = text[start:pos].rsplit("\n", 1)[-1]
+            after = text[pos:end].split("\n", 1)[0]
+            return before + after + "\n" + " " * len(before.expandtabs()) + "^\n"
+        else:
+            before = text[start:pos].rsplit(b"\n", 1)[-1]
+            after = text[pos:end].split(b"\n", 1)[0]
+            return (
+                before + after + b"\n" + b" " * len(before.expandtabs()) + b"^\n"
+            ).decode("ascii", "backslashreplace")
+
+    def match_examples(
+        self,
+        parse_fn: "Callable[[str], Tree]",
+        examples: Union[Mapping[T, Iterable[str]], Iterable[Tuple[T, Iterable[str]]]],
+        token_type_match_fallback: bool = False,
+        use_accepts: bool = True,
+    ) -> Optional[T]:
+        #--
+        assert self.state is not None, "Not supported for this exception"
+
+        if isinstance(examples, Mapping):
+            examples = examples.items()
+
+        candidate = (None, False)
+        for i, (label, example) in enumerate(examples):
+            assert not isinstance(example, str), "Expecting a list"
+
+            for j, malformed in enumerate(example):
+                try:
+                    parse_fn(malformed)
+                except UnexpectedInput as ut:
+                    if ut.state == self.state:
+                        if (
+                            use_accepts
+                            and isinstance(self, UnexpectedToken)
+                            and isinstance(ut, UnexpectedToken)
+                            and ut.accepts != self.accepts
+                        ):
+                            logger.debug(
+                                "Different accepts with same state[%d]: %s != %s at example [%s][%s]"
+                                % (self.state, self.accepts, ut.accepts, i, j)
+                            )
+                            continue
+                        if isinstance(
+                            self, (UnexpectedToken, UnexpectedEOF)
+                        ) and isinstance(ut, (UnexpectedToken, UnexpectedEOF)):
+                            if ut.token == self.token:  ##
+
+                                logger.debug("Exact Match at example [%s][%s]" % (i, j))
+                                return label
+
+                            if token_type_match_fallback:
+                                ##
+
+                                if (ut.token.type == self.token.type) and not candidate[
+                                    -1
+                                ]:
+                                    logger.debug(
+                                        "Token Type Fallback at example [%s][%s]"
+                                        % (i, j)
+                                    )
+                                    candidate = label, True
+
+                        if candidate[0] is None:
+                            logger.debug(
+                                "Same State match at example [%s][%s]" % (i, j)
+                            )
+                            candidate = label, False
+
+        return candidate[0]
+
+    def _format_expected(self, expected):
+        if self._terminals_by_name:
+            d = self._terminals_by_name
+            expected = [
+                d[t_name].user_repr() if t_name in d else t_name for t_name in expected
+            ]
+        return "Expected one of: \n\t* %s\n" % "\n\t* ".join(expected)
+
+
+class UnexpectedEOF(ParseError, UnexpectedInput):
+    #--
+
+    expected: "List[Token]"
+
+    def __init__(self, expected, state=None, terminals_by_name=None):
+        super(UnexpectedEOF, self).__init__()
+
+        self.expected = expected
+        self.state = state
+        from .lexer import Token
+
+        self.token = Token("<EOF>", "")  ##
+
+        self.pos_in_stream = -1
+        self.line = -1
+        self.column = -1
+        self._terminals_by_name = terminals_by_name
+
+    def __str__(self):
+        message = "Unexpected end-of-input. "
+        message += self._format_expected(self.expected)
+        return message
+
+
+class UnexpectedCharacters(LexError, UnexpectedInput):
+    #--
+
+    allowed: Set[str]
+    considered_tokens: Set[Any]
+
+    def __init__(
+        self,
+        seq,
+        lex_pos,
+        line,
+        column,
+        allowed=None,
+        considered_tokens=None,
+        state=None,
+        token_history=None,
+        terminals_by_name=None,
+        considered_rules=None,
+    ):
+        super(UnexpectedCharacters, self).__init__()
+
+        ##
+
+        self.line = line
+        self.column = column
+        self.pos_in_stream = lex_pos
+        self.state = state
+        self._terminals_by_name = terminals_by_name
+
+        self.allowed = allowed
+        self.considered_tokens = considered_tokens
+        self.considered_rules = considered_rules
+        self.token_history = token_history
+
+        if isinstance(seq, bytes):
+            self.char = seq[lex_pos : lex_pos + 1].decode("ascii", "backslashreplace")
+        else:
+            self.char = seq[lex_pos]
+        self._context = self.get_context(seq)
+
+    def __str__(self):
+        message = (
+            "No terminal matches '%s' in the current parser context, at line %d col %d"
+            % (self.char, self.line, self.column)
+        )
+        message += "\n\n" + self._context
+        if self.allowed:
+            message += self._format_expected(self.allowed)
+        if self.token_history:
+            message += "\nPrevious tokens: %s\n" % ", ".join(
+                repr(t) for t in self.token_history
+            )
+        return message
+
+
+class UnexpectedToken(ParseError, UnexpectedInput):
+    #--
+
+    expected: Set[str]
+    considered_rules: Set[str]
+
+    def __init__(
+        self,
+        token,
+        expected,
+        considered_rules=None,
+        state=None,
+        interactive_parser=None,
+        terminals_by_name=None,
+        token_history=None,
+    ):
+        super(UnexpectedToken, self).__init__()
+
+        ##
+
+        self.line = getattr(token, "line", "?")
+        self.column = getattr(token, "column", "?")
+        self.pos_in_stream = getattr(token, "start_pos", None)
+        self.state = state
+
+        self.token = token
+        self.expected = expected  ##
+
+        self._accepts = NO_VALUE
+        self.considered_rules = considered_rules
+        self.interactive_parser = interactive_parser
+        self._terminals_by_name = terminals_by_name
+        self.token_history = token_history
+
+    @property
+    def accepts(self) -> Set[str]:
+        if self._accepts is NO_VALUE:
+            self._accepts = (
+                self.interactive_parser and self.interactive_parser.accepts()
+            )
+        return self._accepts
+
+    def __str__(self):
+        message = "Unexpected token %r at line %s, column %s.\n%s" % (
+            self.token,
+            self.line,
+            self.column,
+            self._format_expected(self.accepts or self.expected),
+        )
+        if self.token_history:
+            message += "Previous tokens: %r\n" % self.token_history
+
+        return message
+
+
+class VisitError(LarkError):
+    #--
+
+    obj: "Union[Tree, Token]"
+    orig_exc: Exception
+
+    def __init__(self, rule, obj, orig_exc):
+        message = 'Error trying to process rule "%s":\n\n%s' % (rule, orig_exc)
+        super(VisitError, self).__init__(message)
+
+        self.rule = rule
+        self.obj = obj
+        self.orig_exc = orig_exc
+
+
+class MissingVariableError(LarkError):
+    pass
+
+
+
+import sys, re
+import logging
+
+logger: logging.Logger = logging.getLogger("lark")
+logger.addHandler(logging.StreamHandler())
+##
+
+##
+
+logger.setLevel(logging.CRITICAL)
+
+
+NO_VALUE = object()
+
+T = TypeVar("T")
+
+
+def classify(
+    seq: Iterable, key: Optional[Callable] = None, value: Optional[Callable] = None
+) -> Dict:
+    d: Dict[Any, Any] = {}
+    for item in seq:
+        k = key(item) if (key is not None) else item
+        v = value(item) if (value is not None) else item
+        try:
+            d[k].append(v)
+        except KeyError:
+            d[k] = [v]
+    return d
+
+
+def _deserialize(data: Any, namespace: Dict[str, Any], memo: Dict) -> Any:
+    if isinstance(data, dict):
+        if "__type__" in data:  ##
+
+            class_ = namespace[data["__type__"]]
+            return class_.deserialize(data, memo)
+        elif "@" in data:
+            return memo[data["@"]]
+        return {
+            key: _deserialize(value, namespace, memo) for key, value in data.items()
+        }
+    elif isinstance(data, list):
+        return [_deserialize(value, namespace, memo) for value in data]
+    return data
+
+
+_T = TypeVar("_T", bound="Serialize")
+
+
+class Serialize:
+    #--
+
+    def memo_serialize(self, types_to_memoize: List) -> Any:
+        memo = SerializeMemoizer(types_to_memoize)
+        return self.serialize(memo), memo.serialize()
+
+    def serialize(self, memo=None) -> Dict[str, Any]:
+        if memo and memo.in_types(self):
+            return {"@": memo.memoized.get(self)}
+
+        fields = getattr(self, "__serialize_fields__")
+        res = {f: _serialize(getattr(self, f), memo) for f in fields}
+        res["__type__"] = type(self).__name__
+        if hasattr(self, "_serialize"):
+            self._serialize(res, memo)  ##
+
+        return res
+
+    @classmethod
+    def deserialize(cls: Type[_T], data: Dict[str, Any], memo: Dict[int, Any]) -> _T:
+        namespace = getattr(cls, "__serialize_namespace__", [])
+        namespace = {c.__name__: c for c in namespace}
+
+        fields = getattr(cls, "__serialize_fields__")
+
+        if "@" in data:
+            return memo[data["@"]]
+
+        inst = cls.__new__(cls)
+        for f in fields:
+            try:
+                setattr(inst, f, _deserialize(data[f], namespace, memo))
+            except KeyError as e:
+                raise KeyError("Cannot find key for class", cls, e)
+
+        if hasattr(inst, "_deserialize"):
+            inst._deserialize()  ##
+
+
+        return inst
+
+
+class SerializeMemoizer(Serialize):
+    #--
+
+    __serialize_fields__ = ("memoized",)
+
+    def __init__(self, types_to_memoize: List) -> None:
+        self.types_to_memoize = tuple(types_to_memoize)
+        self.memoized = Enumerator()
+
+    def in_types(self, value: Serialize) -> bool:
+        return isinstance(value, self.types_to_memoize)
+
+    def serialize(self) -> Dict[int, Any]:  ##
+
+        return _serialize(self.memoized.reversed(), None)
+
+    @classmethod
+    def deserialize(cls, data: Dict[int, Any], namespace: Dict[str, Any], memo: Dict[Any, Any]) -> Dict[int, Any]:  ##
+
+        return _deserialize(data, namespace, memo)
+
+
+try:
+    import regex
+
+    _has_regex = True
+except ImportError:
+    _has_regex = False
+
+if sys.version_info >= (3, 11):
+    import re._parser as sre_parse
+    import re._constants as sre_constants
+else:
+    import sre_parse
+    import sre_constants
+
+categ_pattern = re.compile(r"\\p{[A-Za-z_]+}")
+
+
+def get_regexp_width(expr: str) -> Union[Tuple[int, int], List[int]]:
+    if _has_regex:
+        ##
+
+        ##
+
+        ##
+
+        regexp_final = re.sub(categ_pattern, "A", expr)
+    else:
+        if re.search(categ_pattern, expr):
+            raise ImportError(
+                "`regex` module must be installed in order to use Unicode categories.",
+                expr,
+            )
+        regexp_final = expr
+    try:
+        ##
+
+        return [int(x) for x in sre_parse.parse(regexp_final).getwidth()]  ##
+
+    except sre_constants.error:
+        if not _has_regex:
+            raise ValueError(expr)
+        else:
+            ##
+
+            ##
+
+            c = regex.compile(regexp_final)
+            ##
+
+            ##
+
+            MAXWIDTH = getattr(sre_parse, "MAXWIDTH", sre_constants.MAXREPEAT)
+            if c.match("") is None:
+                ##
+
+                return 1, int(MAXWIDTH)
+            else:
+                return 0, int(MAXWIDTH)
+
+
+
+from collections import OrderedDict
+
+
+class Meta:
+
+    empty: bool
+    line: int
+    column: int
+    start_pos: int
+    end_line: int
+    end_column: int
+    end_pos: int
+    orig_expansion: "List[TerminalDef]"
+    match_tree: bool
+
+    def __init__(self):
+        self.empty = True
+
+
+_Leaf_T = TypeVar("_Leaf_T")
+Branch = Union[_Leaf_T, "Tree[_Leaf_T]"]
+
+
+class Tree(Generic[_Leaf_T]):
+    #--
+
+    data: str
+    children: "List[Branch[_Leaf_T]]"
+
+    def __init__(
+        self, data: str, children: "List[Branch[_Leaf_T]]", meta: Optional[Meta] = None
+    ) -> None:
+        self.data = data
+        self.children = children
+        self._meta = meta
+
+    @property
+    def meta(self) -> Meta:
+        if self._meta is None:
+            self._meta = Meta()
+        return self._meta
+
+    def __repr__(self):
+        return "Tree(%r, %r)" % (self.data, self.children)
+
+    def _pretty_label(self):
+        return self.data
+
+    def _pretty(self, level, indent_str):
+        yield f"{indent_str*level}{self._pretty_label()}"
+        if len(self.children) == 1 and not isinstance(self.children[0], Tree):
+            yield f"\t{self.children[0]}\n"
+        else:
+            yield "\n"
+            for n in self.children:
+                if isinstance(n, Tree):
+                    yield from n._pretty(level + 1, indent_str)
+                else:
+                    yield f"{indent_str*(level+1)}{n}\n"
+
+    def pretty(self, indent_str: str = "  ") -> str:
+        #--
+        return "".join(self._pretty(0, indent_str))
+
+    def __rich__(self, parent: Optional["rich.tree.Tree"] = None) -> "rich.tree.Tree":
+        #--
+        return self._rich(parent)
+
+    def _rich(self, parent):
+        if parent:
+            tree = parent.add(f"[bold]{self.data}[/bold]")
+        else:
+            import rich.tree
+
+            tree = rich.tree.Tree(self.data)
+
+        for c in self.children:
+            if isinstance(c, Tree):
+                c._rich(tree)
+            else:
+                tree.add(f"[green]{c}[/green]")
+
+        return tree
+
+    def __eq__(self, other):
+        try:
+            return self.data == other.data and self.children == other.children
+        except AttributeError:
+            return False
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((self.data, tuple(self.children)))
+
+    def iter_subtrees(self) -> "Iterator[Tree[_Leaf_T]]":
+        #--
+        queue = [self]
+        subtrees = OrderedDict()
+        for subtree in queue:
+            subtrees[id(subtree)] = subtree
+            ##
+
+            queue += [
+                c
+                for c in reversed(subtree.children)  ##
+
+                if isinstance(c, Tree) and id(c) not in subtrees
+            ]
+
+        del queue
+        return reversed(list(subtrees.values()))
+
+    def iter_subtrees_topdown(self):
+        #--
+        stack = [self]
+        stack_append = stack.append
+        stack_pop = stack.pop
+        while stack:
+            node = stack_pop()
+            if not isinstance(node, Tree):
+                continue
+            yield node
+            for child in reversed(node.children):
+                stack_append(child)
+
+    def find_pred(
+        self, pred: "Callable[[Tree[_Leaf_T]], bool]"
+    ) -> "Iterator[Tree[_Leaf_T]]":
+        #--
+        return filter(pred, self.iter_subtrees())
+
+    def find_data(self, data: str) -> "Iterator[Tree[_Leaf_T]]":
+        #--
+        return self.find_pred(lambda t: t.data == data)
+
+
+from functools import wraps, update_wrapper
+from inspect import getmembers, getmro
+
+_Return_T = TypeVar("_Return_T")
+_Return_V = TypeVar("_Return_V")
+_Leaf_T = TypeVar("_Leaf_T")
+_Leaf_U = TypeVar("_Leaf_U")
+_R = TypeVar("_R")
+_FUNC = Callable[..., _Return_T]
+_DECORATED = Union[_FUNC, type]
+
+
+class _DiscardType:
+    #--
+
+    def __repr__(self):
+        return "lark.visitors.Discard"
+
+
+Discard = _DiscardType()
+
+##
+
+
+
+class _Decoratable:
+    #--
+
+    @classmethod
+    def _apply_v_args(cls, visit_wrapper):
+        mro = getmro(cls)
+        assert mro[0] is cls
+        libmembers = {name for _cls in mro[1:] for name, _ in getmembers(_cls)}
+        for name, value in getmembers(cls):
+
+            ##
+
+            if name.startswith("_") or (
+                name in libmembers and name not in cls.__dict__
+            ):
+                continue
+            if not callable(value):
+                continue
+
+            ##
+
+            if isinstance(cls.__dict__[name], _VArgsWrapper):
+                continue
+
+            setattr(cls, name, _VArgsWrapper(cls.__dict__[name], visit_wrapper))
+        return cls
+
+    def __class_getitem__(cls, _):
+        return cls
+
+
+class Transformer(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]):
+    #--
+
+    __visit_tokens__ = True  ##
+
+
+    def __init__(self, visit_tokens: bool = True) -> None:
+        self.__visit_tokens__ = visit_tokens
+
+    def _call_userfunc(self, tree, new_children=None):
+        ##
+
+        children = new_children if new_children is not None else tree.children
+        try:
+            f = getattr(self, tree.data)
+        except AttributeError:
+            return self.__default__(tree.data, children, tree.meta)
+        else:
+            try:
+                wrapper = getattr(f, "visit_wrapper", None)
+                if wrapper is not None:
+                    return f.visit_wrapper(f, tree.data, children, tree.meta)
+                else:
+                    return f(children)
+            except GrammarError:
+                raise
+            except Exception as e:
+                raise VisitError(tree.data, tree, e)
+
+    def _call_userfunc_token(self, token):
+        try:
+            f = getattr(self, token.type)
+        except AttributeError:
+            return self.__default_token__(token)
+        else:
+            try:
+                return f(token)
+            except GrammarError:
+                raise
+            except Exception as e:
+                raise VisitError(token.type, token, e)
+
+    def _transform_children(self, children):
+        for c in children:
+            if isinstance(c, Tree):
+                res = self._transform_tree(c)
+            elif self.__visit_tokens__ and isinstance(c, Token):
+                res = self._call_userfunc_token(c)
+            else:
+                res = c
+
+            if res is not Discard:
+                yield res
+
+    def _transform_tree(self, tree):
+        children = list(self._transform_children(tree.children))
+        return self._call_userfunc(tree, children)
+
+    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        #--
+        return self._transform_tree(tree)
+
+    def __mul__(
+        self: "Transformer[_Leaf_T, Tree[_Leaf_U]]",
+        other: "Union[Transformer[_Leaf_U, _Return_V], TransformerChain[_Leaf_U, _Return_V,]]",
+    ) -> "TransformerChain[_Leaf_T, _Return_V]":
+        #--
+        return TransformerChain(self, other)
+
+    def __default__(self, data, children, meta):
+        #--
+        return Tree(data, children, meta)
+
+    def __default_token__(self, token):
+        #--
+        return token
+
+
+def merge_transformers(base_transformer=None, **transformers_to_merge):
+    #--
+    if base_transformer is None:
+        base_transformer = Transformer()
+    for prefix, transformer in transformers_to_merge.items():
+        for method_name in dir(transformer):
+            method = getattr(transformer, method_name)
+            if not callable(method):
+                continue
+            if method_name.startswith("_") or method_name == "transform":
+                continue
+            prefixed_method = prefix + "__" + method_name
+            if hasattr(base_transformer, prefixed_method):
+                raise AttributeError(
+                    "Cannot merge: method '%s' appears more than once" % prefixed_method
+                )
+
+            setattr(base_transformer, prefixed_method, method)
+
+    return base_transformer
+
+
+class InlineTransformer(Transformer):  ##
+
+    def _call_userfunc(self, tree, new_children=None):
+        ##
+
+        children = new_children if new_children is not None else tree.children
+        try:
+            f = getattr(self, tree.data)
+        except AttributeError:
+            return self.__default__(tree.data, children, tree.meta)
+        else:
+            return f(*children)
+
+
+class TransformerChain(Generic[_Leaf_T, _Return_T]):
+
+    transformers: "Tuple[Union[Transformer, TransformerChain], ...]"
+
+    def __init__(self, *transformers: "Union[Transformer, TransformerChain]") -> None:
+        self.transformers = transformers
+
+    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        for t in self.transformers:
+            tree = t.transform(tree)
+        return cast(_Return_T, tree)
+
+    def __mul__(
+        self: "TransformerChain[_Leaf_T, Tree[_Leaf_U]]",
+        other: "Union[Transformer[_Leaf_U, _Return_V], TransformerChain[_Leaf_U, _Return_V]]",
+    ) -> "TransformerChain[_Leaf_T, _Return_V]":
+        return TransformerChain(*self.transformers + (other,))
+
+
+class Transformer_InPlace(Transformer[_Leaf_T, _Return_T]):
+    #--
+
+    def _transform_tree(self, tree):  ##
+
+        return self._call_userfunc(tree)
+
+    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        for subtree in tree.iter_subtrees():
+            subtree.children = list(self._transform_children(subtree.children))
+
+        return self._transform_tree(tree)
+
+
+class Transformer_NonRecursive(Transformer[_Leaf_T, _Return_T]):
+    #--
+
+    def transform(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        ##
+
+        rev_postfix = []
+        q: List[Branch[_Leaf_T]] = [tree]
+        while q:
+            t = q.pop()
+            rev_postfix.append(t)
+            if isinstance(t, Tree):
+                q += t.children
+
+        ##
+
+        stack: List = []
+        for x in reversed(rev_postfix):
+            if isinstance(x, Tree):
+                size = len(x.children)
+                if size:
+                    args = stack[-size:]
+                    del stack[-size:]
+                else:
+                    args = []
+
+                res = self._call_userfunc(x, args)
+                if res is not Discard:
+                    stack.append(res)
+
+            elif self.__visit_tokens__ and isinstance(x, Token):
+                res = self._call_userfunc_token(x)
+                if res is not Discard:
+                    stack.append(res)
+            else:
+                stack.append(x)
+
+        (result,) = stack  ##
+
+        ##
+
+        ##
+
+        ##
+
+        return cast(_Return_T, result)
+
+
+class Transformer_InPlaceRecursive(Transformer):
+    #--
+
+    def _transform_tree(self, tree):
+        tree.children = list(self._transform_children(tree.children))
+        return self._call_userfunc(tree)
+
+
+##
+
+
+
+class VisitorBase:
+    def _call_userfunc(self, tree):
+        return getattr(self, tree.data, self.__default__)(tree)
+
+    def __default__(self, tree):
+        #--
+        return tree
+
+    def __class_getitem__(cls, _):
+        return cls
+
+
+class Visitor(VisitorBase, ABC, Generic[_Leaf_T]):
+    #--
+
+    def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]:
+        #--
+        for subtree in tree.iter_subtrees():
+            self._call_userfunc(subtree)
+        return tree
+
+    def visit_topdown(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]:
+        #--
+        for subtree in tree.iter_subtrees_topdown():
+            self._call_userfunc(subtree)
+        return tree
+
+
+class Visitor_Recursive(VisitorBase, Generic[_Leaf_T]):
+    #--
+
+    def visit(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]:
+        #--
+        for child in tree.children:
+            if isinstance(child, Tree):
+                self.visit(child)
+
+        self._call_userfunc(tree)
+        return tree
+
+    def visit_topdown(self, tree: Tree[_Leaf_T]) -> Tree[_Leaf_T]:
+        #--
+        self._call_userfunc(tree)
+
+        for child in tree.children:
+            if isinstance(child, Tree):
+                self.visit_topdown(child)
+
+        return tree
+
+
+class Interpreter(_Decoratable, ABC, Generic[_Leaf_T, _Return_T]):
+    #--
+
+    def visit(self, tree: Tree[_Leaf_T]) -> _Return_T:
+        ##
+
+        ##
+
+        ##
+
+        return self._visit_tree(tree)
+
+    def _visit_tree(self, tree: Tree[_Leaf_T]):
+        f = getattr(self, tree.data)
+        wrapper = getattr(f, "visit_wrapper", None)
+        if wrapper is not None:
+            return f.visit_wrapper(f, tree.data, tree.children, tree.meta)
+        else:
+            return f(tree)
+
+    def visit_children(self, tree: Tree[_Leaf_T]) -> List:
+        return [
+            self._visit_tree(child) if isinstance(child, Tree) else child
+            for child in tree.children
+        ]
+
+    def __getattr__(self, name):
+        return self.__default__
+
+    def __default__(self, tree):
+        return self.visit_children(tree)
+
+
+_InterMethod = Callable[[Type[Interpreter], _Return_T], _R]
+
+
+def visit_children_decor(func: _InterMethod) -> _InterMethod:
+    #--
+
+    @wraps(func)
+    def inner(cls, tree):
+        values = cls.visit_children(tree)
+        return func(cls, values)
+
+    return inner
+
+
+##
+
+
+
+def _apply_v_args(obj, visit_wrapper):
+    try:
+        _apply = obj._apply_v_args
+    except AttributeError:
+        return _VArgsWrapper(obj, visit_wrapper)
+    else:
+        return _apply(visit_wrapper)
+
+
+class _VArgsWrapper:
+    #--
+
+    base_func: Callable
+
+    def __init__(
+        self, func: Callable, visit_wrapper: Callable[[Callable, str, list, Any], Any]
+    ):
+        if isinstance(func, _VArgsWrapper):
+            func = func.base_func
+        ##
+
+        self.base_func = func  ##
+
+        self.visit_wrapper = visit_wrapper
+        update_wrapper(self, func)
+
+    def __call__(self, *args, **kwargs):
+        return self.base_func(*args, **kwargs)
+
+    def __get__(self, instance, owner=None):
+        try:
+            ##
+
+            ##
+
+            g = type(self.base_func).__get__
+        except AttributeError:
+            return self
+        else:
+            return _VArgsWrapper(g(self.base_func, instance, owner), self.visit_wrapper)
+
+    def __set_name__(self, owner, name):
+        try:
+            f = type(self.base_func).__set_name__
+        except AttributeError:
+            return
+        else:
+            f(self.base_func, owner, name)
+
+
+def _vargs_inline(f, _data, children, _meta):
+    return f(*children)
+
+
+def _vargs_meta_inline(f, _data, children, meta):
+    return f(meta, *children)
+
+
+def _vargs_meta(f, _data, children, meta):
+    return f(meta, children)
+
+
+def _vargs_tree(f, data, children, meta):
+    return f(Tree(data, children, meta))
+
+
+def v_args(
+    inline: bool = False,
+    meta: bool = False,
+    tree: bool = False,
+    wrapper: Optional[Callable] = None,
+) -> Callable[[_DECORATED], _DECORATED]:
+    #--
+    if tree and (meta or inline):
+        raise ValueError(
+            "Visitor functions cannot combine 'tree' with 'meta' or 'inline'."
+        )
+
+    func = None
+    if meta:
+        if inline:
+            func = _vargs_meta_inline
+        else:
+            func = _vargs_meta
+    elif inline:
+        func = _vargs_inline
+    elif tree:
+        func = _vargs_tree
+
+    if wrapper is not None:
+        if func is not None:
+            raise ValueError(
+                "Cannot use 'wrapper' along with 'tree', 'meta' or 'inline'."
+            )
+        func = wrapper
+
+    def _visitor_args_dec(obj):
+        return _apply_v_args(obj, func)
+
+    return _visitor_args_dec
+
+
+
+TOKEN_DEFAULT_PRIORITY = 0
+
+
+class Symbol(Serialize):
+    __slots__ = ("name",)
+
+    name: str
+    is_term: ClassVar[bool] = NotImplemented
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __eq__(self, other):
+        assert isinstance(other, Symbol), other
+        return self.is_term == other.is_term and self.name == other.name
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __repr__(self):
+        return "%s(%r)" % (type(self).__name__, self.name)
+
+    fullrepr = property(__repr__)
+
+    def renamed(self, f):
+        return type(self)(f(self.name))
+
+
+class Terminal(Symbol):
+    __serialize_fields__ = "name", "filter_out"
+
+    is_term: ClassVar[bool] = True
+
+    def __init__(self, name, filter_out=False):
+        self.name = name
+        self.filter_out = filter_out
+
+    @property
+    def fullrepr(self):
+        return "%s(%r, %r)" % (type(self).__name__, self.name, self.filter_out)
+
+    def renamed(self, f):
+        return type(self)(f(self.name), self.filter_out)
+
+
+class NonTerminal(Symbol):
+    __serialize_fields__ = ("name",)
+
+    is_term: ClassVar[bool] = False
+
+
+class RuleOptions(Serialize):
+    __serialize_fields__ = (
+        "keep_all_tokens",
+        "expand1",
+        "priority",
+        "template_source",
+        "empty_indices",
+    )
+
+    keep_all_tokens: bool
+    expand1: bool
+    priority: Optional[int]
+    template_source: Optional[str]
+    empty_indices: Tuple[bool, ...]
+
+    def __init__(
+        self,
+        keep_all_tokens: bool = False,
+        expand1: bool = False,
+        priority: Optional[int] = None,
+        template_source: Optional[str] = None,
+        empty_indices: Tuple[bool, ...] = (),
+    ) -> None:
+        self.keep_all_tokens = keep_all_tokens
+        self.expand1 = expand1
+        self.priority = priority
+        self.template_source = template_source
+        self.empty_indices = empty_indices
+
+    def __repr__(self):
+        return "RuleOptions(%r, %r, %r, %r)" % (
+            self.keep_all_tokens,
+            self.expand1,
+            self.priority,
+            self.template_source,
+        )
+
+
+class Rule(Serialize):
+    #--
+
+    __slots__ = ("origin", "expansion", "alias", "options", "order", "_hash")
+
+    __serialize_fields__ = "origin", "expansion", "order", "alias", "options"
+    __serialize_namespace__ = Terminal, NonTerminal, RuleOptions
+
+    origin: NonTerminal
+    expansion: Sequence[Symbol]
+    order: int
+    alias: Optional[str]
+    options: RuleOptions
+    _hash: int
+
+    def __init__(
+        self,
+        origin: NonTerminal,
+        expansion: Sequence[Symbol],
+        order: int = 0,
+        alias: Optional[str] = None,
+        options: Optional[RuleOptions] = None,
+    ):
+        self.origin = origin
+        self.expansion = expansion
+        self.alias = alias
+        self.order = order
+        self.options = options or RuleOptions()
+        self._hash = hash((self.origin, tuple(self.expansion)))
+
+    def _deserialize(self):
+        self._hash = hash((self.origin, tuple(self.expansion)))
+
+    def __str__(self):
+        return "<%s : %s>" % (
+            self.origin.name,
+            " ".join(x.name for x in self.expansion),
+        )
+
+    def __repr__(self):
+        return "Rule(%r, %r, %r, %r)" % (
+            self.origin,
+            self.expansion,
+            self.alias,
+            self.options,
+        )
+
+    def __hash__(self):
+        return self._hash
+
+    def __eq__(self, other):
+        if not isinstance(other, Rule):
+            return False
+        return self.origin == other.origin and self.expansion == other.expansion
+
+
+
+from copy import copy
+
+try:  ##
+
+    has_interegular = bool(interegular)
+except NameError:
+    has_interegular = False
+
+
+class Pattern(Serialize, ABC):
+    #--
+
+    value: str
+    flags: Collection[str]
+    raw: Optional[str]
+    type: ClassVar[str]
+
+    def __init__(
+        self, value: str, flags: Collection[str] = (), raw: Optional[str] = None
+    ) -> None:
+        self.value = value
+        self.flags = frozenset(flags)
+        self.raw = raw
+
+    def __repr__(self):
+        return repr(self.to_regexp())
+
+    ##
+
+    def __hash__(self):
+        return hash((type(self), self.value, self.flags))
+
+    def __eq__(self, other):
+        return (
+            type(self) == type(other)
+            and self.value == other.value
+            and self.flags == other.flags
+        )
+
+    @abstractmethod
+    def to_regexp(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def min_width(self) -> int:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def max_width(self) -> int:
+        raise NotImplementedError()
+
+    def _get_flags(self, value):
+        for f in self.flags:
+            value = "(?%s:%s)" % (f, value)
+        return value
+
+
+class PatternStr(Pattern):
+    __serialize_fields__ = "value", "flags", "raw"
+
+    type: ClassVar[str] = "str"
+
+    def to_regexp(self) -> str:
+        return self._get_flags(re.escape(self.value))
+
+    @property
+    def min_width(self) -> int:
+        return len(self.value)
+
+    @property
+    def max_width(self) -> int:
+        return len(self.value)
+
+
+class PatternRE(Pattern):
+    __serialize_fields__ = "value", "flags", "raw", "_width"
+
+    type: ClassVar[str] = "re"
+
+    def to_regexp(self) -> str:
+        return self._get_flags(self.value)
+
+    _width = None
+
+    def _get_width(self):
+        if self._width is None:
+            self._width = get_regexp_width(self.to_regexp())
+        return self._width
+
+    @property
+    def min_width(self) -> int:
+        return self._get_width()[0]
+
+    @property
+    def max_width(self) -> int:
+        return self._get_width()[1]
+
+
+class TerminalDef(Serialize):
+    #--
+    __serialize_fields__ = "name", "pattern", "priority"
+    __serialize_namespace__ = PatternStr, PatternRE
+
+    name: str
+    pattern: Pattern
+    priority: int
+
+    def __init__(
+        self, name: str, pattern: Pattern, priority: int = TOKEN_DEFAULT_PRIORITY
+    ) -> None:
+        assert isinstance(pattern, Pattern), pattern
+        self.name = name
+        self.pattern = pattern
+        self.priority = priority
+
+    def __repr__(self):
+        return "%s(%r, %r)" % (type(self).__name__, self.name, self.pattern)
+
+    def user_repr(self) -> str:
+        if self.name.startswith("__"):  ##
+
+            return self.pattern.raw or self.name
+        else:
+            return self.name
+
+
+_T = TypeVar("_T", bound="Token")
+
+
+class Token(str):
+    #--
+
+    __slots__ = (
+        "type",
+        "start_pos",
+        "value",
+        "line",
+        "column",
+        "end_line",
+        "end_column",
+        "end_pos",
+    )
+
+    __match_args__ = ("type", "value")
+
+    type: str
+    start_pos: Optional[int]
+    value: Any
+    line: Optional[int]
+    column: Optional[int]
+    end_line: Optional[int]
+    end_column: Optional[int]
+    end_pos: Optional[int]
+
+    @overload
+    def __new__(
+        cls,
+        type: str,
+        value: Any,
+        start_pos: Optional[int] = None,
+        line: Optional[int] = None,
+        column: Optional[int] = None,
+        end_line: Optional[int] = None,
+        end_column: Optional[int] = None,
+        end_pos: Optional[int] = None,
+    ) -> "Token": ...
+
+    @overload
+    def __new__(
+        cls,
+        type_: str,
+        value: Any,
+        start_pos: Optional[int] = None,
+        line: Optional[int] = None,
+        column: Optional[int] = None,
+        end_line: Optional[int] = None,
+        end_column: Optional[int] = None,
+        end_pos: Optional[int] = None,
+    ) -> "Token": ...
+
+    def __new__(cls, *args, **kwargs):
+        if "type_" in kwargs:
+            warnings.warn(
+                "`type_` is deprecated use `type` instead", DeprecationWarning
+            )
+
+            if "type" in kwargs:
+                raise TypeError(
+                    "Error: using both 'type' and the deprecated 'type_' as arguments."
+                )
+            kwargs["type"] = kwargs.pop("type_")
+
+        return cls._future_new(*args, **kwargs)
+
+    @classmethod
+    def _future_new(
+        cls,
+        type,
+        value,
+        start_pos=None,
+        line=None,
+        column=None,
+        end_line=None,
+        end_column=None,
+        end_pos=None,
+    ):
+        inst = super(Token, cls).__new__(cls, value)
+
+        inst.type = type
+        inst.start_pos = start_pos
+        inst.value = value
+        inst.line = line
+        inst.column = column
+        inst.end_line = end_line
+        inst.end_column = end_column
+        inst.end_pos = end_pos
+        return inst
+
+    @overload
+    def update(
+        self, type: Optional[str] = None, value: Optional[Any] = None
+    ) -> "Token": ...
+
+    @overload
+    def update(
+        self, type_: Optional[str] = None, value: Optional[Any] = None
+    ) -> "Token": ...
+
+    def update(self, *args, **kwargs):
+        if "type_" in kwargs:
+            warnings.warn(
+                "`type_` is deprecated use `type` instead", DeprecationWarning
+            )
+
+            if "type" in kwargs:
+                raise TypeError(
+                    "Error: using both 'type' and the deprecated 'type_' as arguments."
+                )
+            kwargs["type"] = kwargs.pop("type_")
+
+        return self._future_update(*args, **kwargs)
+
+    def _future_update(
+        self, type: Optional[str] = None, value: Optional[Any] = None
+    ) -> "Token":
+        return Token.new_borrow_pos(
+            type if type is not None else self.type,
+            value if value is not None else self.value,
+            self,
+        )
+
+    @classmethod
+    def new_borrow_pos(cls: Type[_T], type_: str, value: Any, borrow_t: "Token") -> _T:
+        return cls(
+            type_,
+            value,
+            borrow_t.start_pos,
+            borrow_t.line,
+            borrow_t.column,
+            borrow_t.end_line,
+            borrow_t.end_column,
+            borrow_t.end_pos,
+        )
+
+    def __reduce__(self):
+        return (
+            self.__class__,
+            (self.type, self.value, self.start_pos, self.line, self.column),
+        )
+
+    def __repr__(self):
+        return "Token(%r, %r)" % (self.type, self.value)
+
+    def __deepcopy__(self, memo):
+        return Token(self.type, self.value, self.start_pos, self.line, self.column)
+
+    def __eq__(self, other):
+        if isinstance(other, Token) and self.type != other.type:
+            return False
+
+        return str.__eq__(self, other)
+
+    __hash__ = str.__hash__
+
+
+class LineCounter:
+    #--
+
+    __slots__ = "char_pos", "line", "column", "line_start_pos", "newline_char"
+
+    def __init__(self, newline_char):
+        self.newline_char = newline_char
+        self.char_pos = 0
+        self.line = 1
+        self.column = 1
+        self.line_start_pos = 0
+
+    def __eq__(self, other):
+        if not isinstance(other, LineCounter):
+            return NotImplemented
+
+        return (
+            self.char_pos == other.char_pos and self.newline_char == other.newline_char
+        )
+
+    def feed(self, token: Token, test_newline=True):
+        #--
+        if test_newline:
+            newlines = token.count(self.newline_char)
+            if newlines:
+                self.line += newlines
+                self.line_start_pos = (
+                    self.char_pos + token.rindex(self.newline_char) + 1
+                )
+
+        self.char_pos += len(token)
+        self.column = self.char_pos - self.line_start_pos + 1
+
+
+class UnlessCallback:
+    def __init__(self, scanner):
+        self.scanner = scanner
+
+    def __call__(self, t):
+        res = self.scanner.match(t.value, 0)
+        if res:
+            _value, t.type = res
+        return t
+
+
+class CallChain:
+    def __init__(self, callback1, callback2, cond):
+        self.callback1 = callback1
+        self.callback2 = callback2
+        self.cond = cond
+
+    def __call__(self, t):
+        t2 = self.callback1(t)
+        return self.callback2(t) if self.cond(t2) else t2
+
+
+def _get_match(re_, regexp, s, flags):
+    m = re_.match(regexp, s, flags)
+    if m:
+        return m.group(0)
+
+
+def _create_unless(terminals, g_regex_flags, re_, use_bytes):
+    tokens_by_type = classify(terminals, lambda t: type(t.pattern))
+    assert len(tokens_by_type) <= 2, tokens_by_type.keys()
+    embedded_strs = set()
+    callback = {}
+    for retok in tokens_by_type.get(PatternRE, []):
+        unless = []
+        for strtok in tokens_by_type.get(PatternStr, []):
+            if strtok.priority != retok.priority:
+                continue
+            s = strtok.pattern.value
+            if s == _get_match(re_, retok.pattern.to_regexp(), s, g_regex_flags):
+                unless.append(strtok)
+                if strtok.pattern.flags <= retok.pattern.flags:
+                    embedded_strs.add(strtok)
+        if unless:
+            callback[retok.name] = UnlessCallback(
+                Scanner(
+                    unless, g_regex_flags, re_, match_whole=True, use_bytes=use_bytes
+                )
+            )
+
+    new_terminals = [t for t in terminals if t not in embedded_strs]
+    return new_terminals, callback
+
+
+class Scanner:
+    def __init__(self, terminals, g_regex_flags, re_, use_bytes, match_whole=False):
+        self.terminals = terminals
+        self.g_regex_flags = g_regex_flags
+        self.re_ = re_
+        self.use_bytes = use_bytes
+        self.match_whole = match_whole
+
+        self.allowed_types = {t.name for t in self.terminals}
+
+        self._mres = self._build_mres(terminals, len(terminals))
+
+    def _build_mres(self, terminals, max_size):
+        ##
+
+        ##
+
+        ##
+
+        postfix = "$" if self.match_whole else ""
+        mres = []
+        while terminals:
+            pattern = "|".join(
+                "(?P<%s>%s)" % (t.name, t.pattern.to_regexp() + postfix)
+                for t in terminals[:max_size]
+            )
+            if self.use_bytes:
+                pattern = pattern.encode("latin-1")
+            try:
+                mre = self.re_.compile(pattern, self.g_regex_flags)
+            except AssertionError:  ##
+
+                return self._build_mres(terminals, max_size // 2)
+
+            mres.append(mre)
+            terminals = terminals[max_size:]
+        return mres
+
+    def match(self, text, pos):
+        for mre in self._mres:
+            m = mre.match(text, pos)
+            if m:
+                return m.group(0), m.lastgroup
+
+
+def _regexp_has_newline(r: str):
+    #--
+    return (
+        "\n" in r or "\\n" in r or "\\s" in r or "[^" in r or ("(?s" in r and "." in r)
+    )
+
+
+class LexerState:
+    #--
+
+    __slots__ = "text", "line_ctr", "last_token"
+
+    text: str
+    line_ctr: LineCounter
+    last_token: Optional[Token]
+
+    def __init__(
+        self,
+        text: str,
+        line_ctr: Optional[LineCounter] = None,
+        last_token: Optional[Token] = None,
+    ):
+        self.text = text
+        self.line_ctr = line_ctr or LineCounter(
+            b"\n" if isinstance(text, bytes) else "\n"
+        )
+        self.last_token = last_token
+
+    def __eq__(self, other):
+        if not isinstance(other, LexerState):
+            return NotImplemented
+
+        return (
+            self.text is other.text
+            and self.line_ctr == other.line_ctr
+            and self.last_token == other.last_token
+        )
+
+    def __copy__(self):
+        return type(self)(self.text, copy(self.line_ctr), self.last_token)
+
+
+class LexerThread:
+    #--
+
+    def __init__(self, lexer: "Lexer", lexer_state: LexerState):
+        self.lexer = lexer
+        self.state = lexer_state
+
+    @classmethod
+    def from_text(cls, lexer: "Lexer", text: str) -> "LexerThread":
+        return cls(lexer, LexerState(text))
+
+    def lex(self, parser_state):
+        return self.lexer.lex(self.state, parser_state)
+
+    def __copy__(self):
+        return type(self)(self.lexer, copy(self.state))
+
+    _Token = Token
+
+
+_Callback = Callable[[Token], Token]
+
+
+class Lexer(ABC):
+    #--
+
+    @abstractmethod
+    def lex(self, lexer_state: LexerState, parser_state: Any) -> Iterator[Token]:
+        return NotImplemented
+
+    def make_lexer_state(self, text):
+        #--
+        return LexerState(text)
+
+
+def _check_regex_collisions(
+    terminal_to_regexp: Dict[TerminalDef, str],
+    comparator,
+    strict_mode,
+    max_collisions_to_show=8,
+):
+    if not comparator:
+        comparator = interegular.Comparator.from_regexes(terminal_to_regexp)
+
+    ##
+
+    ##
+
+    max_time = 2 if strict_mode else 0.2
+
+    ##
+
+    if comparator.count_marked_pairs() >= max_collisions_to_show:
+        return
+    for group in classify(terminal_to_regexp, lambda t: t.priority).values():
+        for a, b in comparator.check(group, skip_marked=True):
+            assert a.priority == b.priority
+            ##
+
+            comparator.mark(a, b)
+
+            ##
+
+            message = f"Collision between Terminals {a.name} and {b.name}. "
+            try:
+                example = comparator.get_example_overlap(
+                    a, b, max_time
+                ).format_multiline()
+            except ValueError:
+                ##
+
+                example = "No example could be found fast enough. However, the collision does still exists"
+            if strict_mode:
+                raise LexError(f"{message}\n{example}")
+            logger.warning(
+                "%s The lexer will choose between them arbitrarily.\n%s",
+                message,
+                example,
+            )
+            if comparator.count_marked_pairs() >= max_collisions_to_show:
+                logger.warning("Found 8 regex collisions, will not check for more.")
+                return
+
+
+class AbstractBasicLexer(Lexer):
+    terminals_by_name: Dict[str, TerminalDef]
+
+    @abstractmethod
+    def __init__(self, conf: "LexerConf", comparator=None) -> None: ...
+
+    @abstractmethod
+    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token: ...
+
+    def lex(self, state: LexerState, parser_state: Any) -> Iterator[Token]:
+        with suppress(EOFError):
+            while True:
+                yield self.next_token(state, parser_state)
+
+
+class BasicLexer(AbstractBasicLexer):
+    terminals: Collection[TerminalDef]
+    ignore_types: FrozenSet[str]
+    newline_types: FrozenSet[str]
+    user_callbacks: Dict[str, _Callback]
+    callback: Dict[str, _Callback]
+    re: ModuleType
+
+    def __init__(self, conf: "LexerConf", comparator=None) -> None:
+        terminals = list(conf.terminals)
+        assert all(isinstance(t, TerminalDef) for t in terminals), terminals
+
+        self.re = conf.re_module
+
+        if not conf.skip_validation:
+            ##
+
+            terminal_to_regexp = {}
+            for t in terminals:
+                regexp = t.pattern.to_regexp()
+                try:
+                    self.re.compile(regexp, conf.g_regex_flags)
+                except self.re.error:
+                    raise LexError("Cannot compile token %s: %s" % (t.name, t.pattern))
+
+                if t.pattern.min_width == 0:
+                    raise LexError(
+                        "Lexer does not allow zero-width terminals. (%s: %s)"
+                        % (t.name, t.pattern)
+                    )
+                if t.pattern.type == "re":
+                    terminal_to_regexp[t] = regexp
+
+            if not (set(conf.ignore) <= {t.name for t in terminals}):
+                raise LexError(
+                    "Ignore terminals are not defined: %s"
+                    % (set(conf.ignore) - {t.name for t in terminals})
+                )
+
+            if has_interegular:
+                _check_regex_collisions(terminal_to_regexp, comparator, conf.strict)
+            elif conf.strict:
+                raise LexError(
+                    "interegular must be installed for strict mode. Use `pip install 'lark[interegular]'`."
+                )
+
+        ##
+
+        self.newline_types = frozenset(
+            t.name for t in terminals if _regexp_has_newline(t.pattern.to_regexp())
+        )
+        self.ignore_types = frozenset(conf.ignore)
+
+        terminals.sort(
+            key=lambda x: (
+                -x.priority,
+                -x.pattern.max_width,
+                -len(x.pattern.value),
+                x.name,
+            )
+        )
+        self.terminals = terminals
+        self.user_callbacks = conf.callbacks
+        self.g_regex_flags = conf.g_regex_flags
+        self.use_bytes = conf.use_bytes
+        self.terminals_by_name = conf.terminals_by_name
+
+        self._scanner = None
+
+    def _build_scanner(self):
+        terminals, self.callback = _create_unless(
+            self.terminals, self.g_regex_flags, self.re, self.use_bytes
+        )
+        assert all(self.callback.values())
+
+        for type_, f in self.user_callbacks.items():
+            if type_ in self.callback:
+                ##
+
+                self.callback[type_] = CallChain(
+                    self.callback[type_], f, lambda t: t.type == type_
+                )
+            else:
+                self.callback[type_] = f
+
+        self._scanner = Scanner(terminals, self.g_regex_flags, self.re, self.use_bytes)
+
+    @property
+    def scanner(self):
+        if self._scanner is None:
+            self._build_scanner()
+        return self._scanner
+
+    def match(self, text, pos):
+        return self.scanner.match(text, pos)
+
+    def next_token(self, lex_state: LexerState, parser_state: Any = None) -> Token:
+        line_ctr = lex_state.line_ctr
+        while line_ctr.char_pos < len(lex_state.text):
+            res = self.match(lex_state.text, line_ctr.char_pos)
+            if not res:
+                allowed = self.scanner.allowed_types - self.ignore_types
+                if not allowed:
+                    allowed = {"<END-OF-FILE>"}
+                raise UnexpectedCharacters(
+                    lex_state.text,
+                    line_ctr.char_pos,
+                    line_ctr.line,
+                    line_ctr.column,
+                    allowed=allowed,
+                    token_history=lex_state.last_token and [lex_state.last_token],
+                    state=parser_state,
+                    terminals_by_name=self.terminals_by_name,
+                )
+
+            value, type_ = res
+
+            ignored = type_ in self.ignore_types
+            t = None
+            if not ignored or type_ in self.callback:
+                t = Token(
+                    type_, value, line_ctr.char_pos, line_ctr.line, line_ctr.column
+                )
+            line_ctr.feed(value, type_ in self.newline_types)
+            if t is not None:
+                t.end_line = line_ctr.line
+                t.end_column = line_ctr.column
+                t.end_pos = line_ctr.char_pos
+                if t.type in self.callback:
+                    t = self.callback[t.type](t)
+                if not ignored:
+                    if not isinstance(t, Token):
+                        raise LexError(
+                            "Callbacks must return a token (returned %r)" % t
+                        )
+                    lex_state.last_token = t
+                    return t
+
+        ##
+
+        raise EOFError(self)
+
+
+class ContextualLexer(Lexer):
+    lexers: Dict[int, AbstractBasicLexer]
+    root_lexer: AbstractBasicLexer
+
+    BasicLexer: Type[AbstractBasicLexer] = BasicLexer
+
+    def __init__(
+        self,
+        conf: "LexerConf",
+        states: Dict[int, Collection[str]],
+        always_accept: Collection[str] = (),
+    ) -> None:
+        terminals = list(conf.terminals)
+        terminals_by_name = conf.terminals_by_name
+
+        trad_conf = copy(conf)
+        trad_conf.terminals = terminals
+
+        if has_interegular and not conf.skip_validation:
+            comparator = interegular.Comparator.from_regexes(
+                {t: t.pattern.to_regexp() for t in terminals}
+            )
+        else:
+            comparator = None
+        lexer_by_tokens: Dict[FrozenSet[str], AbstractBasicLexer] = {}
+        self.lexers = {}
+        for state, accepts in states.items():
+            key = frozenset(accepts)
+            try:
+                lexer = lexer_by_tokens[key]
+            except KeyError:
+                accepts = set(accepts) | set(conf.ignore) | set(always_accept)
+                lexer_conf = copy(trad_conf)
+                lexer_conf.terminals = [
+                    terminals_by_name[n] for n in accepts if n in terminals_by_name
+                ]
+                lexer = self.BasicLexer(lexer_conf, comparator)
+                lexer_by_tokens[key] = lexer
+
+            self.lexers[state] = lexer
+
+        assert trad_conf.terminals is terminals
+        trad_conf.skip_validation = True  ##
+
+        self.root_lexer = self.BasicLexer(trad_conf, comparator)
+
+    def lex(
+        self, lexer_state: LexerState, parser_state: "ParserState"
+    ) -> Iterator[Token]:
+        try:
+            while True:
+                lexer = self.lexers[parser_state.position]
+                yield lexer.next_token(lexer_state, parser_state)
+        except EOFError:
+            pass
+        except UnexpectedCharacters as e:
+            ##
+
+            ##
+
+            try:
+                last_token = (
+                    lexer_state.last_token
+                )  ##
+
+                token = self.root_lexer.next_token(lexer_state, parser_state)
+                raise UnexpectedToken(
+                    token,
+                    e.allowed,
+                    state=parser_state,
+                    token_history=[last_token],
+                    terminals_by_name=self.root_lexer.terminals_by_name,
+                )
+            except UnexpectedCharacters:
+                raise e  ##
+
+
+
+
+
+_ParserArgType: "TypeAlias" = 'Literal["earley", "lalr", "cyk", "auto"]'
+_LexerArgType: "TypeAlias" = (
+    'Union[Literal["auto", "basic", "contextual", "dynamic", "dynamic_complete"], Type[Lexer]]'
+)
+_LexerCallback = Callable[[Token], Token]
+ParserCallbacks = Dict[str, Callable]
+
+
+class LexerConf(Serialize):
+    __serialize_fields__ = (
+        "terminals",
+        "ignore",
+        "g_regex_flags",
+        "use_bytes",
+        "lexer_type",
+    )
+    __serialize_namespace__ = (TerminalDef,)
+
+    terminals: Collection[TerminalDef]
+    re_module: ModuleType
+    ignore: Collection[str]
+    postlex: "Optional[PostLex]"
+    callbacks: Dict[str, _LexerCallback]
+    g_regex_flags: int
+    skip_validation: bool
+    use_bytes: bool
+    lexer_type: Optional[_LexerArgType]
+    strict: bool
+
+    def __init__(
+        self,
+        terminals: Collection[TerminalDef],
+        re_module: ModuleType,
+        ignore: Collection[str] = (),
+        postlex: "Optional[PostLex]" = None,
+        callbacks: Optional[Dict[str, _LexerCallback]] = None,
+        g_regex_flags: int = 0,
+        skip_validation: bool = False,
+        use_bytes: bool = False,
+        strict: bool = False,
+    ):
+        self.terminals = terminals
+        self.terminals_by_name = {t.name: t for t in self.terminals}
+        assert len(self.terminals) == len(self.terminals_by_name)
+        self.ignore = ignore
+        self.postlex = postlex
+        self.callbacks = callbacks or {}
+        self.g_regex_flags = g_regex_flags
+        self.re_module = re_module
+        self.skip_validation = skip_validation
+        self.use_bytes = use_bytes
+        self.strict = strict
+        self.lexer_type = None
+
+    def _deserialize(self):
+        self.terminals_by_name = {t.name: t for t in self.terminals}
+
+    def __deepcopy__(self, memo=None):
+        return type(self)(
+            deepcopy(self.terminals, memo),
+            self.re_module,
+            deepcopy(self.ignore, memo),
+            deepcopy(self.postlex, memo),
+            deepcopy(self.callbacks, memo),
+            deepcopy(self.g_regex_flags, memo),
+            deepcopy(self.skip_validation, memo),
+            deepcopy(self.use_bytes, memo),
+        )
+
+
+class ParserConf(Serialize):
+    __serialize_fields__ = "rules", "start", "parser_type"
+
+    rules: List["Rule"]
+    callbacks: ParserCallbacks
+    start: List[str]
+    parser_type: _ParserArgType
+
+    def __init__(
+        self, rules: List["Rule"], callbacks: ParserCallbacks, start: List[str]
+    ):
+        assert isinstance(start, list)
+        self.rules = rules
+        self.callbacks = callbacks
+        self.start = start
+
+
+
+from functools import partial, wraps
+from itertools import product
+
+
+class ExpandSingleChild:
+    def __init__(self, node_builder):
+        self.node_builder = node_builder
+
+    def __call__(self, children):
+        if len(children) == 1:
+            return children[0]
+        else:
+            return self.node_builder(children)
+
+
+class PropagatePositions:
+    def __init__(self, node_builder, node_filter=None):
+        self.node_builder = node_builder
+        self.node_filter = node_filter
+
+    def __call__(self, children):
+        res = self.node_builder(children)
+
+        if isinstance(res, Tree):
+            ##
+
+            ##
+
+            ##
+
+            ##
+
+
+            res_meta = res.meta
+
+            first_meta = self._pp_get_meta(children)
+            if first_meta is not None:
+                if not hasattr(res_meta, "line"):
+                    ##
+
+                    res_meta.line = getattr(
+                        first_meta, "container_line", first_meta.line
+                    )
+                    res_meta.column = getattr(
+                        first_meta, "container_column", first_meta.column
+                    )
+                    res_meta.start_pos = getattr(
+                        first_meta, "container_start_pos", first_meta.start_pos
+                    )
+                    res_meta.empty = False
+
+                res_meta.container_line = getattr(
+                    first_meta, "container_line", first_meta.line
+                )
+                res_meta.container_column = getattr(
+                    first_meta, "container_column", first_meta.column
+                )
+                res_meta.container_start_pos = getattr(
+                    first_meta, "container_start_pos", first_meta.start_pos
+                )
+
+            last_meta = self._pp_get_meta(reversed(children))
+            if last_meta is not None:
+                if not hasattr(res_meta, "end_line"):
+                    res_meta.end_line = getattr(
+                        last_meta, "container_end_line", last_meta.end_line
+                    )
+                    res_meta.end_column = getattr(
+                        last_meta, "container_end_column", last_meta.end_column
+                    )
+                    res_meta.end_pos = getattr(
+                        last_meta, "container_end_pos", last_meta.end_pos
+                    )
+                    res_meta.empty = False
+
+                res_meta.container_end_line = getattr(
+                    last_meta, "container_end_line", last_meta.end_line
+                )
+                res_meta.container_end_column = getattr(
+                    last_meta, "container_end_column", last_meta.end_column
+                )
+                res_meta.container_end_pos = getattr(
+                    last_meta, "container_end_pos", last_meta.end_pos
+                )
+
+        return res
+
+    def _pp_get_meta(self, children):
+        for c in children:
+            if self.node_filter is not None and not self.node_filter(c):
+                continue
+            if isinstance(c, Tree):
+                if not c.meta.empty:
+                    return c.meta
+            elif isinstance(c, Token):
+                return c
+            elif hasattr(c, "__lark_meta__"):
+                return c.__lark_meta__()
+
+
+def make_propagate_positions(option):
+    if callable(option):
+        return partial(PropagatePositions, node_filter=option)
+    elif option is True:
+        return PropagatePositions
+    elif option is False:
+        return None
+
+    raise ConfigurationError("Invalid option for propagate_positions: %r" % option)
+
+
+class ChildFilter:
+    def __init__(self, to_include, append_none, node_builder):
+        self.node_builder = node_builder
+        self.to_include = to_include
+        self.append_none = append_none
+
+    def __call__(self, children):
+        filtered = []
+
+        for i, to_expand, add_none in self.to_include:
+            if add_none:
+                filtered += [None] * add_none
+            if to_expand:
+                filtered += children[i].children
+            else:
+                filtered.append(children[i])
+
+        if self.append_none:
+            filtered += [None] * self.append_none
+
+        return self.node_builder(filtered)
+
+
+class ChildFilterLALR(ChildFilter):
+    #--
+
+    def __call__(self, children):
+        filtered = []
+        for i, to_expand, add_none in self.to_include:
+            if add_none:
+                filtered += [None] * add_none
+            if to_expand:
+                if filtered:
+                    filtered += children[i].children
+                else:  ##
+
+                    filtered = children[i].children
+            else:
+                filtered.append(children[i])
+
+        if self.append_none:
+            filtered += [None] * self.append_none
+
+        return self.node_builder(filtered)
+
+
+class ChildFilterLALR_NoPlaceholders(ChildFilter):
+    #--
+
+    def __init__(self, to_include, node_builder):
+        self.node_builder = node_builder
+        self.to_include = to_include
+
+    def __call__(self, children):
+        filtered = []
+        for i, to_expand in self.to_include:
+            if to_expand:
+                if filtered:
+                    filtered += children[i].children
+                else:  ##
+
+                    filtered = children[i].children
+            else:
+                filtered.append(children[i])
+        return self.node_builder(filtered)
+
+
+def _should_expand(sym):
+    return not sym.is_term and sym.name.startswith("_")
+
+
+def maybe_create_child_filter(
+    expansion, keep_all_tokens, ambiguous, _empty_indices: List[bool]
+):
+    ##
+
+    if _empty_indices:
+        assert _empty_indices.count(False) == len(expansion)
+        s = "".join(str(int(b)) for b in _empty_indices)
+        empty_indices = [len(ones) for ones in s.split("0")]
+        assert len(empty_indices) == len(expansion) + 1, (empty_indices, len(expansion))
+    else:
+        empty_indices = [0] * (len(expansion) + 1)
+
+    to_include = []
+    nones_to_add = 0
+    for i, sym in enumerate(expansion):
+        nones_to_add += empty_indices[i]
+        if keep_all_tokens or not (sym.is_term and sym.filter_out):
+            to_include.append((i, _should_expand(sym), nones_to_add))
+            nones_to_add = 0
+
+    nones_to_add += empty_indices[len(expansion)]
+
+    if (
+        _empty_indices
+        or len(to_include) < len(expansion)
+        or any(to_expand for i, to_expand, _ in to_include)
+    ):
+        if _empty_indices or ambiguous:
+            return partial(
+                ChildFilter if ambiguous else ChildFilterLALR, to_include, nones_to_add
+            )
+        else:
+            ##
+
+            return partial(
+                ChildFilterLALR_NoPlaceholders, [(i, x) for i, x, _ in to_include]
+            )
+
+
+class AmbiguousExpander:
+    #--
+
+    def __init__(self, to_expand, tree_class, node_builder):
+        self.node_builder = node_builder
+        self.tree_class = tree_class
+        self.to_expand = to_expand
+
+    def __call__(self, children):
+        def _is_ambig_tree(t):
+            return hasattr(t, "data") and t.data == "_ambig"
+
+        ##
+
+        ##
+
+        ##
+
+        ##
+
+        ambiguous = []
+        for i, child in enumerate(children):
+            if _is_ambig_tree(child):
+                if i in self.to_expand:
+                    ambiguous.append(i)
+
+                child.expand_kids_by_data("_ambig")
+
+        if not ambiguous:
+            return self.node_builder(children)
+
+        expand = [
+            child.children if i in ambiguous else (child,)
+            for i, child in enumerate(children)
+        ]
+        return self.tree_class(
+            "_ambig", [self.node_builder(list(f)) for f in product(*expand)]
+        )
+
+
+def maybe_create_ambiguous_expander(tree_class, expansion, keep_all_tokens):
+    to_expand = [
+        i
+        for i, sym in enumerate(expansion)
+        if keep_all_tokens
+        or ((not (sym.is_term and sym.filter_out)) and _should_expand(sym))
+    ]
+    if to_expand:
+        return partial(AmbiguousExpander, to_expand, tree_class)
+
+
+class AmbiguousIntermediateExpander:
+    #--
+
+    def __init__(self, tree_class, node_builder):
+        self.node_builder = node_builder
+        self.tree_class = tree_class
+
+    def __call__(self, children):
+        def _is_iambig_tree(child):
+            return hasattr(child, "data") and child.data == "_iambig"
+
+        def _collapse_iambig(children):
+            #--
+
+            ##
+
+            ##
+
+            if children and _is_iambig_tree(children[0]):
+                iambig_node = children[0]
+                result = []
+                for grandchild in iambig_node.children:
+                    collapsed = _collapse_iambig(grandchild.children)
+                    if collapsed:
+                        for child in collapsed:
+                            child.children += children[1:]
+                        result += collapsed
+                    else:
+                        new_tree = self.tree_class(
+                            "_inter", grandchild.children + children[1:]
+                        )
+                        result.append(new_tree)
+                return result
+
+        collapsed = _collapse_iambig(children)
+        if collapsed:
+            processed_nodes = [self.node_builder(c.children) for c in collapsed]
+            return self.tree_class("_ambig", processed_nodes)
+
+        return self.node_builder(children)
+
+
+def inplace_transformer(func):
+    @wraps(func)
+    def f(children):
+        ##
+
+        tree = Tree(func.__name__, children)
+        return func(tree)
+
+    return f
+
+
+def apply_visit_wrapper(func, name, wrapper):
+    if wrapper is _vargs_meta or wrapper is _vargs_meta_inline:
+        raise NotImplementedError("Meta args not supported for internal transformer")
+
+    @wraps(func)
+    def f(children):
+        return wrapper(func, name, children, None)
+
+    return f
+
+
+class ParseTreeBuilder:
+    def __init__(
+        self,
+        rules,
+        tree_class,
+        propagate_positions=False,
+        ambiguous=False,
+        maybe_placeholders=False,
+    ):
+        self.tree_class = tree_class
+        self.propagate_positions = propagate_positions
+        self.ambiguous = ambiguous
+        self.maybe_placeholders = maybe_placeholders
+
+        self.rule_builders = list(self._init_builders(rules))
+
+    def _init_builders(self, rules):
+        propagate_positions = make_propagate_positions(self.propagate_positions)
+
+        for rule in rules:
+            options = rule.options
+            keep_all_tokens = options.keep_all_tokens
+            expand_single_child = options.expand1
+
+            wrapper_chain = list(
+                filter(
+                    None,
+                    [
+                        (expand_single_child and not rule.alias) and ExpandSingleChild,
+                        maybe_create_child_filter(
+                            rule.expansion,
+                            keep_all_tokens,
+                            self.ambiguous,
+                            options.empty_indices if self.maybe_placeholders else None,
+                        ),
+                        propagate_positions,
+                        self.ambiguous
+                        and maybe_create_ambiguous_expander(
+                            self.tree_class, rule.expansion, keep_all_tokens
+                        ),
+                        self.ambiguous
+                        and partial(AmbiguousIntermediateExpander, self.tree_class),
+                    ],
+                )
+            )
+
+            yield rule, wrapper_chain
+
+    def create_callback(self, transformer=None):
+        callbacks = {}
+
+        default_handler = getattr(transformer, "__default__", None)
+        if default_handler:
+
+            def default_callback(data, children):
+                return default_handler(data, children, None)
+
+        else:
+            default_callback = self.tree_class
+
+        for rule, wrapper_chain in self.rule_builders:
+
+            user_callback_name = (
+                rule.alias or rule.options.template_source or rule.origin.name
+            )
+            try:
+                f = getattr(transformer, user_callback_name)
+                wrapper = getattr(f, "visit_wrapper", None)
+                if wrapper is not None:
+                    f = apply_visit_wrapper(f, user_callback_name, wrapper)
+                elif isinstance(transformer, Transformer_InPlace):
+                    f = inplace_transformer(f)
+            except AttributeError:
+                f = partial(default_callback, user_callback_name)
+
+            for w in wrapper_chain:
+                f = w(f)
+
+            if rule in callbacks:
+                raise GrammarError("Rule '%s' already exists" % (rule,))
+
+            callbacks[rule] = f
+
+        return callbacks
+
+
+
+
+
+class Action:
+    def __init__(self, name):
+        self.name = name
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return str(self)
+
+
+Shift = Action("Shift")
+Reduce = Action("Reduce")
+
+StateT = TypeVar("StateT")
+
+
+class ParseTableBase(Generic[StateT]):
+    states: Dict[StateT, Dict[str, Tuple]]
+    start_states: Dict[str, StateT]
+    end_states: Dict[str, StateT]
+
+    def __init__(self, states, start_states, end_states):
+        self.states = states
+        self.start_states = start_states
+        self.end_states = end_states
+
+    def serialize(self, memo):
+        tokens = Enumerator()
+
+        states = {
+            state: {
+                tokens.get(token): (
+                    (1, arg.serialize(memo)) if action is Reduce else (0, arg)
+                )
+                for token, (action, arg) in actions.items()
+            }
+            for state, actions in self.states.items()
+        }
+
+        return {
+            "tokens": tokens.reversed(),
+            "states": states,
+            "start_states": self.start_states,
+            "end_states": self.end_states,
+        }
+
+    @classmethod
+    def deserialize(cls, data, memo):
+        tokens = data["tokens"]
+        states = {
+            state: {
+                tokens[token]: (
+                    (Reduce, Rule.deserialize(arg, memo))
+                    if action == 1
+                    else (Shift, arg)
+                )
+                for token, (action, arg) in actions.items()
+            }
+            for state, actions in data["states"].items()
+        }
+        return cls(states, data["start_states"], data["end_states"])
+
+
+class ParseTable(ParseTableBase["State"]):
+    #--
+
+    pass
+
+
+class IntParseTable(ParseTableBase[int]):
+    #--
+
+    @classmethod
+    def from_ParseTable(cls, parse_table: ParseTable):
+        enum = list(parse_table.states)
+        state_to_idx: Dict["State", int] = {s: i for i, s in enumerate(enum)}
+        int_states = {}
+
+        for s, la in parse_table.states.items():
+            la = {
+                k: (v[0], state_to_idx[v[1]]) if v[0] is Shift else v
+                for k, v in la.items()
+            }
+            int_states[state_to_idx[s]] = la
+
+        start_states = {
+            start: state_to_idx[s] for start, s in parse_table.start_states.items()
+        }
+        end_states = {
+            start: state_to_idx[s] for start, s in parse_table.end_states.items()
+        }
+        return cls(int_states, start_states, end_states)
+
+
+
+
+
+class ParseConf(Generic[StateT]):
+    __slots__ = (
+        "parse_table",
+        "callbacks",
+        "start",
+        "start_state",
+        "end_state",
+        "states",
+    )
+
+    parse_table: ParseTableBase[StateT]
+    callbacks: ParserCallbacks
+    start: str
+
+    start_state: StateT
+    end_state: StateT
+    states: Dict[StateT, Dict[str, tuple]]
+
+    def __init__(
+        self,
+        parse_table: ParseTableBase[StateT],
+        callbacks: ParserCallbacks,
+        start: str,
+    ):
+        self.parse_table = parse_table
+
+        self.start_state = self.parse_table.start_states[start]
+        self.end_state = self.parse_table.end_states[start]
+        self.states = self.parse_table.states
+
+        self.callbacks = callbacks
+        self.start = start
+
+
+class ParserState(Generic[StateT]):
+    __slots__ = "parse_conf", "lexer", "state_stack", "value_stack"
+
+    parse_conf: ParseConf[StateT]
+    lexer: LexerThread
+    state_stack: List[StateT]
+    value_stack: list
+
+    def __init__(
+        self,
+        parse_conf: ParseConf[StateT],
+        lexer: LexerThread,
+        state_stack=None,
+        value_stack=None,
+    ):
+        self.parse_conf = parse_conf
+        self.lexer = lexer
+        self.state_stack = state_stack or [self.parse_conf.start_state]
+        self.value_stack = value_stack or []
+
+    @property
+    def position(self) -> StateT:
+        return self.state_stack[-1]
+
+    ##
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, ParserState):
+            return NotImplemented
+        return (
+            len(self.state_stack) == len(other.state_stack)
+            and self.position == other.position
+        )
+
+    def __copy__(self):
+        return type(self)(
+            self.parse_conf,
+            self.lexer,  ##
+
+            copy(self.state_stack),
+            deepcopy(self.value_stack),
+        )
+
+    def copy(self) -> "ParserState[StateT]":
+        return copy(self)
+
+    def feed_token(self, token: Token, is_end=False) -> Any:
+        state_stack = self.state_stack
+        value_stack = self.value_stack
+        states = self.parse_conf.states
+        end_state = self.parse_conf.end_state
+        callbacks = self.parse_conf.callbacks
+
+        while True:
+            state = state_stack[-1]
+            try:
+                action, arg = states[state][token.type]
+            except KeyError:
+                expected = {s for s in states[state].keys() if s.isupper()}
+                raise UnexpectedToken(
+                    token, expected, state=self, interactive_parser=None
+                )
+
+            assert arg != end_state
+
+            if action is Shift:
+                ##
+
+                assert not is_end
+                state_stack.append(arg)
+                value_stack.append(
+                    token
+                    if token.type not in callbacks
+                    else callbacks[token.type](token)
+                )
+                return
+            else:
+                ##
+
+                rule = arg
+                size = len(rule.expansion)
+                if size:
+                    s = value_stack[-size:]
+                    del state_stack[-size:]
+                    del value_stack[-size:]
+                else:
+                    s = []
+
+                value = callbacks[rule](s) if callbacks else s
+
+                _action, new_state = states[state_stack[-1]][rule.origin.name]
+                assert _action is Shift
+                state_stack.append(new_state)
+                value_stack.append(value)
+
+                if is_end and state_stack[-1] == end_state:
+                    return value_stack[-1]
+
+
+
+
+
+class LALR_Parser(Serialize):
+    def __init__(
+        self, parser_conf: ParserConf, debug: bool = False, strict: bool = False
+    ):
+        analysis = LALR_Analyzer(parser_conf, debug=debug, strict=strict)
+        analysis.compute_lalr()
+        callbacks = parser_conf.callbacks
+
+        self._parse_table = analysis.parse_table
+        self.parser_conf = parser_conf
+        self.parser = _Parser(analysis.parse_table, callbacks, debug)
+
+    @classmethod
+    def deserialize(cls, data, memo, callbacks, debug=False):
+        inst = cls.__new__(cls)
+        inst._parse_table = IntParseTable.deserialize(data, memo)
+        inst.parser = _Parser(inst._parse_table, callbacks, debug)
+        return inst
+
+    def serialize(self, memo: Any = None) -> Dict[str, Any]:
+        return self._parse_table.serialize(memo)
+
+    def parse_interactive(self, lexer: LexerThread, start: str):
+        return self.parser.parse(lexer, start, start_interactive=True)
+
+    def parse(self, lexer, start, on_error=None):
+        try:
+            return self.parser.parse(lexer, start)
+        except UnexpectedInput as e:
+            if on_error is None:
+                raise
+
+            while True:
+                if isinstance(e, UnexpectedCharacters):
+                    s = e.interactive_parser.lexer_thread.state
+                    p = s.line_ctr.char_pos
+
+                if not on_error(e):
+                    raise e
+
+                if isinstance(e, UnexpectedCharacters):
+                    ##
+
+                    if p == s.line_ctr.char_pos:
+                        s.line_ctr.feed(s.text[p : p + 1])
+
+                try:
+                    return e.interactive_parser.resume_parse()
+                except UnexpectedToken as e2:
+                    if (
+                        isinstance(e, UnexpectedToken)
+                        and e.token.type == e2.token.type == "$END"
+                        and e.interactive_parser == e2.interactive_parser
+                    ):
+                        ##
+
+                        raise e2
+                    e = e2
+                except UnexpectedCharacters as e2:
+                    e = e2
+
+
+class _Parser:
+    parse_table: ParseTableBase
+    callbacks: ParserCallbacks
+    debug: bool
+
+    def __init__(
+        self,
+        parse_table: ParseTableBase,
+        callbacks: ParserCallbacks,
+        debug: bool = False,
+    ):
+        self.parse_table = parse_table
+        self.callbacks = callbacks
+        self.debug = debug
+
+    def parse(
+        self,
+        lexer: LexerThread,
+        start: str,
+        value_stack=None,
+        state_stack=None,
+        start_interactive=False,
+    ):
+        parse_conf = ParseConf(self.parse_table, self.callbacks, start)
+        parser_state = ParserState(parse_conf, lexer, state_stack, value_stack)
+        if start_interactive:
+            return InteractiveParser(self, parser_state, parser_state.lexer)
+        return self.parse_from_state(parser_state)
+
+    def parse_from_state(self, state: ParserState, last_token: Optional[Token] = None):
+        #--
+        try:
+            token = last_token
+            for token in state.lexer.lex(state):
+                assert token is not None
+                state.feed_token(token)
+
+            end_token = (
+                Token.new_borrow_pos("$END", "", token)
+                if token
+                else Token("$END", "", 0, 1, 1)
+            )
+            return state.feed_token(end_token, True)
+        except UnexpectedInput as e:
+            try:
+                e.interactive_parser = InteractiveParser(self, state, state.lexer)
+            except NameError:
+                pass
+            raise e
+        except Exception as e:
+            if self.debug:
+                print("")
+                print("STATE STACK DUMP")
+                print("----------------")
+                for i, s in enumerate(state.state_stack):
+                    print("%d)" % i, s)
+                print("")
+
+            raise
+
+
+
+
+
+class InteractiveParser:
+    #--
+
+    def __init__(self, parser, parser_state, lexer_thread: LexerThread):
+        self.parser = parser
+        self.parser_state = parser_state
+        self.lexer_thread = lexer_thread
+        self.result = None
+
+    @property
+    def lexer_state(self) -> LexerThread:
+        warnings.warn(
+            "lexer_state will be removed in subsequent releases. Use lexer_thread instead.",
+            DeprecationWarning,
+        )
+        return self.lexer_thread
+
+    def feed_token(self, token: Token):
+        #--
+        return self.parser_state.feed_token(token, token.type == "$END")
+
+    def iter_parse(self) -> Iterator[Token]:
+        #--
+        for token in self.lexer_thread.lex(self.parser_state):
+            yield token
+            self.result = self.feed_token(token)
+
+    def exhaust_lexer(self) -> List[Token]:
+        #--
+        return list(self.iter_parse())
+
+    def feed_eof(self, last_token=None):
+        #--
+        eof = (
+            Token.new_borrow_pos("$END", "", last_token)
+            if last_token is not None
+            else self.lexer_thread._Token("$END", "", 0, 1, 1)
+        )
+        return self.feed_token(eof)
+
+    def __copy__(self):
+        #--
+        return type(self)(
+            self.parser,
+            copy(self.parser_state),
+            copy(self.lexer_thread),
+        )
+
+    def copy(self):
+        return copy(self)
+
+    def __eq__(self, other):
+        if not isinstance(other, InteractiveParser):
+            return False
+
+        return (
+            self.parser_state == other.parser_state
+            and self.lexer_thread == other.lexer_thread
+        )
+
+    def as_immutable(self):
+        #--
+        p = copy(self)
+        return ImmutableInteractiveParser(p.parser, p.parser_state, p.lexer_thread)
+
+    def pretty(self):
+        #--
+        out = ["Parser choices:"]
+        for k, v in self.choices().items():
+            out.append("\t- %s -> %r" % (k, v))
+        out.append("stack size: %s" % len(self.parser_state.state_stack))
+        return "\n".join(out)
+
+    def choices(self):
+        #--
+        return self.parser_state.parse_conf.parse_table.states[
+            self.parser_state.position
+        ]
+
+    def accepts(self):
+        #--
+        accepts = set()
+        conf_no_callbacks = copy(self.parser_state.parse_conf)
+        ##
+
+        ##
+
+        conf_no_callbacks.callbacks = {}
+        for t in self.choices():
+            if t.isupper():  ##
+
+                new_cursor = copy(self)
+                new_cursor.parser_state.parse_conf = conf_no_callbacks
+                try:
+                    new_cursor.feed_token(self.lexer_thread._Token(t, ""))
+                except UnexpectedToken:
+                    pass
+                else:
+                    accepts.add(t)
+        return accepts
+
+    def resume_parse(self):
+        #--
+        return self.parser.parse_from_state(
+            self.parser_state, last_token=self.lexer_thread.state.last_token
+        )
+
+
+class ImmutableInteractiveParser(InteractiveParser):
+    #--
+
+    result = None
+
+    def __hash__(self):
+        return hash((self.parser_state, self.lexer_thread))
+
+    def feed_token(self, token):
+        c = copy(self)
+        c.result = InteractiveParser.feed_token(c, token)
+        return c
+
+    def exhaust_lexer(self):
+        #--
+        cursor = self.as_mutable()
+        cursor.exhaust_lexer()
+        return cursor.as_immutable()
+
+    def as_mutable(self):
+        #--
+        p = copy(self)
+        return InteractiveParser(p.parser, p.parser_state, p.lexer_thread)
+
+
+
+
+
+def _wrap_lexer(lexer_class):
+    future_interface = getattr(lexer_class, "__future_interface__", False)
+    if future_interface:
+        return lexer_class
+    else:
+
+        class CustomLexerWrapper(Lexer):
+            def __init__(self, lexer_conf):
+                self.lexer = lexer_class(lexer_conf)
+
+            def lex(self, lexer_state, parser_state):
+                return self.lexer.lex(lexer_state.text)
+
+        return CustomLexerWrapper
+
+
+def _deserialize_parsing_frontend(data, memo, lexer_conf, callbacks, options):
+    parser_conf = ParserConf.deserialize(data["parser_conf"], memo)
+    cls = (options and options._plugins.get("LALR_Parser")) or LALR_Parser
+    parser = cls.deserialize(data["parser"], memo, callbacks, options.debug)
+    parser_conf.callbacks = callbacks
+    return ParsingFrontend(lexer_conf, parser_conf, options, parser=parser)
+
+
+_parser_creators: "Dict[str, Callable[[LexerConf, Any, Any], Any]]" = {}
+
+
+class ParsingFrontend(Serialize):
+    __serialize_fields__ = "lexer_conf", "parser_conf", "parser"
+
+    lexer_conf: LexerConf
+    parser_conf: ParserConf
+    options: Any
+
+    def __init__(
+        self, lexer_conf: LexerConf, parser_conf: ParserConf, options, parser=None
+    ):
+        self.parser_conf = parser_conf
+        self.lexer_conf = lexer_conf
+        self.options = options
+
+        ##
+
+        if parser:  ##
+
+            self.parser = parser
+        else:
+            create_parser = _parser_creators.get(parser_conf.parser_type)
+            assert (
+                create_parser is not None
+            ), "{} is not supported in standalone mode".format(parser_conf.parser_type)
+            self.parser = create_parser(lexer_conf, parser_conf, options)
+
+        ##
+
+        lexer_type = lexer_conf.lexer_type
+        self.skip_lexer = False
+        if lexer_type in ("dynamic", "dynamic_complete"):
+            assert lexer_conf.postlex is None
+            self.skip_lexer = True
+            return
+
+        if isinstance(lexer_type, type):
+            assert issubclass(lexer_type, Lexer)
+            self.lexer = _wrap_lexer(lexer_type)(lexer_conf)
+        elif isinstance(lexer_type, str):
+            create_lexer = {
+                "basic": create_basic_lexer,
+                "contextual": create_contextual_lexer,
+            }[lexer_type]
+            self.lexer = create_lexer(
+                lexer_conf, self.parser, lexer_conf.postlex, options
+            )
+        else:
+            raise TypeError("Bad value for lexer_type: {lexer_type}")
+
+        if lexer_conf.postlex:
+            self.lexer = PostLexConnector(self.lexer, lexer_conf.postlex)
+
+    def _verify_start(self, start=None):
+        if start is None:
+            start_decls = self.parser_conf.start
+            if len(start_decls) > 1:
+                raise ConfigurationError(
+                    "Lark initialized with more than 1 possible start rule. Must specify which start rule to parse",
+                    start_decls,
+                )
+            (start,) = start_decls
+        elif start not in self.parser_conf.start:
+            raise ConfigurationError(
+                "Unknown start rule %s. Must be one of %r"
+                % (start, self.parser_conf.start)
+            )
+        return start
+
+    def _make_lexer_thread(self, text: str) -> Union[str, LexerThread]:
+        cls = (self.options and self.options._plugins.get("LexerThread")) or LexerThread
+        return text if self.skip_lexer else cls.from_text(self.lexer, text)
+
+    def parse(self, text: str, start=None, on_error=None):
+        chosen_start = self._verify_start(start)
+        kw = {} if on_error is None else {"on_error": on_error}
+        stream = self._make_lexer_thread(text)
+        return self.parser.parse(stream, chosen_start, **kw)
+
+    def parse_interactive(self, text: Optional[str] = None, start=None):
+        ##
+
+        ##
+
+        chosen_start = self._verify_start(start)
+        if self.parser_conf.parser_type != "lalr":
+            raise ConfigurationError(
+                "parse_interactive() currently only works with parser='lalr' "
+            )
+        stream = self._make_lexer_thread(text)  ##
+
+        return self.parser.parse_interactive(stream, chosen_start)
+
+
+def _validate_frontend_args(parser, lexer) -> None:
+    assert_config(parser, ("lalr", "earley", "cyk"))
+    if not isinstance(lexer, type):  ##
+
+        expected = {
+            "lalr": ("basic", "contextual"),
+            "earley": ("basic", "dynamic", "dynamic_complete"),
+            "cyk": ("basic",),
+        }[parser]
+        assert_config(
+            lexer,
+            expected,
+            "Parser %r does not support lexer %%r, expected one of %%s" % parser,
+        )
+
+
+def _get_lexer_callbacks(transformer, terminals):
+    result = {}
+    for terminal in terminals:
+        callback = getattr(transformer, terminal.name, None)
+        if callback is not None:
+            result[terminal.name] = callback
+    return result
+
+
+class PostLexConnector:
+    def __init__(self, lexer, postlexer):
+        self.lexer = lexer
+        self.postlexer = postlexer
+
+    def lex(self, lexer_state, parser_state):
+        i = self.lexer.lex(lexer_state, parser_state)
+        return self.postlexer.process(i)
+
+
+def create_basic_lexer(lexer_conf, parser, postlex, options) -> BasicLexer:
+    cls = (options and options._plugins.get("BasicLexer")) or BasicLexer
+    return cls(lexer_conf)
+
+
+def create_contextual_lexer(
+    lexer_conf: LexerConf, parser, postlex, options
+) -> ContextualLexer:
+    cls = (options and options._plugins.get("ContextualLexer")) or ContextualLexer
+    parse_table: ParseTableBase[int] = parser._parse_table
+    states: Dict[int, Collection[str]] = {
+        idx: list(t.keys()) for idx, t in parse_table.states.items()
+    }
+    always_accept: Collection[str] = postlex.always_accept if postlex else ()
+    return cls(lexer_conf, states, always_accept=always_accept)
+
+
+def create_lalr_parser(
+    lexer_conf: LexerConf, parser_conf: ParserConf, options=None
+) -> LALR_Parser:
+    debug = options.debug if options else False
+    strict = options.strict if options else False
+    cls = (options and options._plugins.get("LALR_Parser")) or LALR_Parser
+    return cls(parser_conf, debug=debug, strict=strict)
+
+
+_parser_creators["lalr"] = create_lalr_parser
+
+
+
+
+class PostLex(ABC):
+    @abstractmethod
+    def process(self, stream: Iterator[Token]) -> Iterator[Token]:
+        return stream
+
+    always_accept: Iterable[str] = ()
+
+
+class LarkOptions(Serialize):
+    #--
+
+    start: List[str]
+    debug: bool
+    strict: bool
+    transformer: "Optional[Transformer]"
+    propagate_positions: Union[bool, str]
+    maybe_placeholders: bool
+    cache: Union[bool, str]
+    regex: bool
+    g_regex_flags: int
+    keep_all_tokens: bool
+    tree_class: Optional[Callable[[str, List], Any]]
+    parser: _ParserArgType
+    lexer: _LexerArgType
+    ambiguity: 'Literal["auto", "resolve", "explicit", "forest"]'
+    postlex: Optional[PostLex]
+    priority: 'Optional[Literal["auto", "normal", "invert"]]'
+    lexer_callbacks: Dict[str, Callable[[Token], Token]]
+    use_bytes: bool
+    ordered_sets: bool
+    edit_terminals: Optional[Callable[[TerminalDef], TerminalDef]]
+    import_paths: "List[Union[str, Callable[[Union[None, str, PackageResource], str], Tuple[str, str]]]]"
+    source_path: Optional[str]
+
+    OPTIONS_DOC = r"""
+    **===  General Options  ===**
+
+    start
+            The start symbol. Either a string, or a list of strings for multiple possible starts (Default: "start")
+    debug
+            Display debug information and extra warnings. Use only when debugging (Default: ``False``)
+            When used with Earley, it generates a forest graph as "sppf.png", if 'dot' is installed.
+    strict
+            Throw an exception on any potential ambiguity, including shift/reduce conflicts, and regex collisions.
+    transformer
+            Applies the transformer to every parse tree (equivalent to applying it after the parse, but faster)
+    propagate_positions
+            Propagates positional attributes into the 'meta' attribute of all tree branches.
+            Sets attributes: (line, column, end_line, end_column, start_pos, end_pos,
+                              container_line, container_column, container_end_line, container_end_column)
+            Accepts ``False``, ``True``, or a callable, which will filter which nodes to ignore when propagating.
+    maybe_placeholders
+            When ``True``, the ``[]`` operator returns ``None`` when not matched.
+            When ``False``,  ``[]`` behaves like the ``?`` operator, and returns no value at all.
+            (default= ``True``)
+    cache
+            Cache the results of the Lark grammar analysis, for x2 to x3 faster loading. LALR only for now.
+
+            - When ``False``, does nothing (default)
+            - When ``True``, caches to a temporary file in the local directory
+            - When given a string, caches to the path pointed by the string
+    regex
+            When True, uses the ``regex`` module instead of the stdlib ``re``.
+    g_regex_flags
+            Flags that are applied to all terminals (both regex and strings)
+    keep_all_tokens
+            Prevent the tree builder from automagically removing "punctuation" tokens (Default: ``False``)
+    tree_class
+            Lark will produce trees comprised of instances of this class instead of the default ``lark.Tree``.
+
+    **=== Algorithm Options ===**
+
+    parser
+            Decides which parser engine to use. Accepts "earley" or "lalr". (Default: "earley").
+            (there is also a "cyk" option for legacy)
+    lexer
+            Decides whether or not to use a lexer stage
+
+            - "auto" (default): Choose for me based on the parser
+            - "basic": Use a basic lexer
+            - "contextual": Stronger lexer (only works with parser="lalr")
+            - "dynamic": Flexible and powerful (only with parser="earley")
+            - "dynamic_complete": Same as dynamic, but tries *every* variation of tokenizing possible.
+    ambiguity
+            Decides how to handle ambiguity in the parse. Only relevant if parser="earley"
+
+            - "resolve": The parser will automatically choose the simplest derivation
+              (it chooses consistently: greedy for tokens, non-greedy for rules)
+            - "explicit": The parser will return all derivations wrapped in "_ambig" tree nodes (i.e. a forest).
+            - "forest": The parser will return the root of the shared packed parse forest.
+
+    **=== Misc. / Domain Specific Options ===**
+
+    postlex
+            Lexer post-processing (Default: ``None``) Only works with the basic and contextual lexers.
+    priority
+            How priorities should be evaluated - "auto", ``None``, "normal", "invert" (Default: "auto")
+    lexer_callbacks
+            Dictionary of callbacks for the lexer. May alter tokens during lexing. Use with caution.
+    use_bytes
+            Accept an input of type ``bytes`` instead of ``str``.
+    ordered_sets
+            Should Earley use ordered-sets to achieve stable output (~10% slower than regular sets. Default: True)
+    edit_terminals
+            A callback for editing the terminals before parse.
+    import_paths
+            A List of either paths or loader functions to specify from where grammars are imported
+    source_path
+            Override the source of from where the grammar was loaded. Useful for relative imports and unconventional grammar loading
+    **=== End of Options ===**
+    """
+    if __doc__:
+        __doc__ += OPTIONS_DOC
+
+    ##
+
+    ##
+
+    ##
+
+    ##
+
+    ##
+
+    ##
+
+    _defaults: Dict[str, Any] = {
+        "debug": False,
+        "strict": False,
+        "keep_all_tokens": False,
+        "tree_class": None,
+        "cache": False,
+        "postlex": None,
+        "parser": "earley",
+        "lexer": "auto",
+        "transformer": None,
+        "start": "start",
+        "priority": "auto",
+        "ambiguity": "auto",
+        "regex": False,
+        "propagate_positions": False,
+        "lexer_callbacks": {},
+        "maybe_placeholders": True,
+        "edit_terminals": None,
+        "g_regex_flags": 0,
+        "use_bytes": False,
+        "ordered_sets": True,
+        "import_paths": [],
+        "source_path": None,
+        "_plugins": {},
+    }
+
+    def __init__(self, options_dict: Dict[str, Any]) -> None:
+        o = dict(options_dict)
+
+        options = {}
+        for name, default in self._defaults.items():
+            if name in o:
+                value = o.pop(name)
+                if isinstance(default, bool) and name not in (
+                    "cache",
+                    "use_bytes",
+                    "propagate_positions",
+                ):
+                    value = bool(value)
+            else:
+                value = default
+
+            options[name] = value
+
+        if isinstance(options["start"], str):
+            options["start"] = [options["start"]]
+
+        self.__dict__["options"] = options
+
+        assert_config(self.parser, ("earley", "lalr", "cyk", None))
+
+        if self.parser == "earley" and self.transformer:
+            raise ConfigurationError(
+                "Cannot specify an embedded transformer when using the Earley algorithm. "
+                "Please use your transformer on the resulting parse tree, or use a different algorithm (i.e. LALR)"
+            )
+
+        if o:
+            raise ConfigurationError("Unknown options: %s" % o.keys())
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self.__dict__["options"][name]
+        except KeyError as e:
+            raise AttributeError(e)
+
+    def __setattr__(self, name: str, value: str) -> None:
+        assert_config(
+            name, self.options.keys(), "%r isn't a valid option. Expected one of: %s"
+        )
+        self.options[name] = value
+
+    def serialize(self, memo=None) -> Dict[str, Any]:
+        return self.options
+
+    @classmethod
+    def deserialize(
+        cls, data: Dict[str, Any], memo: Dict[int, Union[TerminalDef, Rule]]
+    ) -> "LarkOptions":
+        return cls(data)
+
+
+##
+
+##
+
+_LOAD_ALLOWED_OPTIONS = {
+    "postlex",
+    "transformer",
+    "lexer_callbacks",
+    "use_bytes",
+    "debug",
+    "g_regex_flags",
+    "regex",
+    "propagate_positions",
+    "tree_class",
+    "_plugins",
+}
+
+_VALID_PRIORITY_OPTIONS = ("auto", "normal", "invert", None)
+_VALID_AMBIGUITY_OPTIONS = ("auto", "resolve", "explicit", "forest")
+
+
+_T = TypeVar("_T", bound="Lark")
+
+
+class Lark(Serialize):
+    #--
+
+    source_path: str
+    source_grammar: str
+    grammar: "Grammar"
+    options: LarkOptions
+    lexer: Lexer
+    parser: "ParsingFrontend"
+    terminals: Collection[TerminalDef]
+
+    def __init__(self, grammar: "Union[Grammar, str, IO[str]]", **options) -> None:
+        self.options = LarkOptions(options)
+        re_module: types.ModuleType
+
+        ##
+
+        use_regex = self.options.regex
+        if use_regex:
+            if _has_regex:
+                re_module = regex
+            else:
+                raise ImportError(
+                    "`regex` module must be installed if calling `Lark(regex=True)`."
+                )
+        else:
+            re_module = re
+
+        ##
+
+        if self.options.source_path is None:
+            try:
+                self.source_path = grammar.name  ##
+
+            except AttributeError:
+                self.source_path = "<string>"
+        else:
+            self.source_path = self.options.source_path
+
+        ##
+
+        try:
+            read = grammar.read  ##
+
+        except AttributeError:
+            pass
+        else:
+            grammar = read()
+
+        cache_fn = None
+        cache_sha256 = None
+        if isinstance(grammar, str):
+            self.source_grammar = grammar
+            if self.options.use_bytes:
+                if not isascii(grammar):
+                    raise ConfigurationError(
+                        "Grammar must be ascii only, when use_bytes=True"
+                    )
+
+            if self.options.cache:
+                if self.options.parser != "lalr":
+                    raise ConfigurationError(
+                        "cache only works with parser='lalr' for now"
+                    )
+
+                unhashable = (
+                    "transformer",
+                    "postlex",
+                    "lexer_callbacks",
+                    "edit_terminals",
+                    "_plugins",
+                )
+                options_str = "".join(
+                    k + str(v) for k, v in options.items() if k not in unhashable
+                )
+                from . import __version__
+
+                s = grammar + options_str + __version__ + str(sys.version_info[:2])
+                cache_sha256 = sha256_digest(s)
+
+                if isinstance(self.options.cache, str):
+                    cache_fn = self.options.cache
+                else:
+                    if self.options.cache is not True:
+                        raise ConfigurationError("cache argument must be bool or str")
+
+                    try:
+                        username = getpass.getuser()
+                    except Exception:
+                        ##
+
+                        ##
+
+                        ##
+
+                        username = "unknown"
+
+                    cache_fn = (
+                        tempfile.gettempdir()
+                        + "/.lark_cache_%s_%s_%s_%s.tmp"
+                        % (username, cache_sha256, *sys.version_info[:2])
+                    )
+
+                old_options = self.options
+                try:
+                    with FS.open(cache_fn, "rb") as f:
+                        logger.debug("Loading grammar from cache: %s", cache_fn)
+                        ##
+
+                        for name in set(options) - _LOAD_ALLOWED_OPTIONS:
+                            del options[name]
+                        file_sha256 = f.readline().rstrip(b"\n")
+                        cached_used_files = pickle.load(f)
+                        if file_sha256 == cache_sha256.encode(
+                            "utf8"
+                        ) and verify_used_files(cached_used_files):
+                            cached_parser_data = pickle.load(f)
+                            self._load(cached_parser_data, **options)
+                            return
+                except FileNotFoundError:
+                    ##
+
+                    pass
+                except (
+                    Exception
+                ):  ##
+
+                    logger.exception(
+                        "Failed to load Lark from cache: %r. We will try to carry on.",
+                        cache_fn,
+                    )
+
+                    ##
+
+                    ##
+
+                    self.options = old_options
+
+            ##
+
+            self.grammar, used_files = load_grammar(
+                grammar,
+                self.source_path,
+                self.options.import_paths,
+                self.options.keep_all_tokens,
+            )
+        else:
+            assert isinstance(grammar, Grammar)
+            self.grammar = grammar
+
+        if self.options.lexer == "auto":
+            if self.options.parser == "lalr":
+                self.options.lexer = "contextual"
+            elif self.options.parser == "earley":
+                if self.options.postlex is not None:
+                    logger.info(
+                        "postlex can't be used with the dynamic lexer, so we use 'basic' instead. "
+                        "Consider using lalr with contextual instead of earley"
+                    )
+                    self.options.lexer = "basic"
+                else:
+                    self.options.lexer = "dynamic"
+            elif self.options.parser == "cyk":
+                self.options.lexer = "basic"
+            else:
+                assert False, self.options.parser
+        lexer = self.options.lexer
+        if isinstance(lexer, type):
+            assert issubclass(
+                lexer, Lexer
+            )  ##
+
+        else:
+            assert_config(lexer, ("basic", "contextual", "dynamic", "dynamic_complete"))
+            if self.options.postlex is not None and "dynamic" in lexer:
+                raise ConfigurationError(
+                    "Can't use postlex with a dynamic lexer. Use basic or contextual instead"
+                )
+
+        if self.options.ambiguity == "auto":
+            if self.options.parser == "earley":
+                self.options.ambiguity = "resolve"
+        else:
+            assert_config(
+                self.options.parser,
+                ("earley", "cyk"),
+                "%r doesn't support disambiguation. Use one of these parsers instead: %s",
+            )
+
+        if self.options.priority == "auto":
+            self.options.priority = "normal"
+
+        if self.options.priority not in _VALID_PRIORITY_OPTIONS:
+            raise ConfigurationError(
+                "invalid priority option: %r. Must be one of %r"
+                % (self.options.priority, _VALID_PRIORITY_OPTIONS)
+            )
+        if self.options.ambiguity not in _VALID_AMBIGUITY_OPTIONS:
+            raise ConfigurationError(
+                "invalid ambiguity option: %r. Must be one of %r"
+                % (self.options.ambiguity, _VALID_AMBIGUITY_OPTIONS)
+            )
+
+        if self.options.parser is None:
+            terminals_to_keep = "*"
+        elif self.options.postlex is not None:
+            terminals_to_keep = set(self.options.postlex.always_accept)
+        else:
+            terminals_to_keep = set()
+
+        ##
+
+        self.terminals, self.rules, self.ignore_tokens = self.grammar.compile(
+            self.options.start, terminals_to_keep
+        )
+
+        if self.options.edit_terminals:
+            for t in self.terminals:
+                self.options.edit_terminals(t)
+
+        self._terminals_dict = {t.name: t for t in self.terminals}
+
+        ##
+
+        if self.options.priority == "invert":
+            for rule in self.rules:
+                if rule.options.priority is not None:
+                    rule.options.priority = -rule.options.priority
+            for term in self.terminals:
+                term.priority = -term.priority
+        ##
+
+        ##
+
+        ##
+
+        elif self.options.priority is None:
+            for rule in self.rules:
+                if rule.options.priority is not None:
+                    rule.options.priority = None
+            for term in self.terminals:
+                term.priority = 0
+
+        ##
+
+        self.lexer_conf = LexerConf(
+            self.terminals,
+            re_module,
+            self.ignore_tokens,
+            self.options.postlex,
+            self.options.lexer_callbacks,
+            self.options.g_regex_flags,
+            use_bytes=self.options.use_bytes,
+            strict=self.options.strict,
+        )
+
+        if self.options.parser:
+            self.parser = self._build_parser()
+        elif lexer:
+            self.lexer = self._build_lexer()
+
+        if cache_fn:
+            logger.debug("Saving grammar to cache: %s", cache_fn)
+            try:
+                with FS.open(cache_fn, "wb") as f:
+                    assert cache_sha256 is not None
+                    f.write(cache_sha256.encode("utf8") + b"\n")
+                    pickle.dump(used_files, f)
+                    self.save(f, _LOAD_ALLOWED_OPTIONS)
+            except IOError as e:
+                logger.exception("Failed to save Lark to cache: %r.", cache_fn, e)
+
+    if __doc__:
+        __doc__ += "\n\n" + LarkOptions.OPTIONS_DOC
+
+    __serialize_fields__ = "parser", "rules", "options"
+
+    def _build_lexer(self, dont_ignore: bool = False) -> BasicLexer:
+        lexer_conf = self.lexer_conf
+        if dont_ignore:
+            from copy import copy
+
+            lexer_conf = copy(lexer_conf)
+            lexer_conf.ignore = ()
+        return BasicLexer(lexer_conf)
+
+    def _prepare_callbacks(self) -> None:
+        self._callbacks = {}
+        ##
+
+        if self.options.ambiguity != "forest":
+            self._parse_tree_builder = ParseTreeBuilder(
+                self.rules,
+                self.options.tree_class or Tree,
+                self.options.propagate_positions,
+                self.options.parser != "lalr" and self.options.ambiguity == "explicit",
+                self.options.maybe_placeholders,
+            )
+            self._callbacks = self._parse_tree_builder.create_callback(
+                self.options.transformer
+            )
+        self._callbacks.update(
+            _get_lexer_callbacks(self.options.transformer, self.terminals)
+        )
+
+    def _build_parser(self) -> "ParsingFrontend":
+        self._prepare_callbacks()
+        _validate_frontend_args(self.options.parser, self.options.lexer)
+        parser_conf = ParserConf(self.rules, self._callbacks, self.options.start)
+        return _construct_parsing_frontend(
+            self.options.parser,
+            self.options.lexer,
+            self.lexer_conf,
+            parser_conf,
+            options=self.options,
+        )
+
+    def save(self, f, exclude_options: Collection[str] = ()) -> None:
+        #--
+        if self.options.parser != "lalr":
+            raise NotImplementedError(
+                "Lark.save() is only implemented for the LALR(1) parser."
+            )
+        data, m = self.memo_serialize([TerminalDef, Rule])
+        if exclude_options:
+            data["options"] = {
+                n: v for n, v in data["options"].items() if n not in exclude_options
+            }
+        pickle.dump({"data": data, "memo": m}, f, protocol=pickle.HIGHEST_PROTOCOL)
+
+    @classmethod
+    def load(cls: Type[_T], f) -> _T:
+        #--
+        inst = cls.__new__(cls)
+        return inst._load(f)
+
+    def _deserialize_lexer_conf(
+        self,
+        data: Dict[str, Any],
+        memo: Dict[int, Union[TerminalDef, Rule]],
+        options: LarkOptions,
+    ) -> LexerConf:
+        lexer_conf = LexerConf.deserialize(data["lexer_conf"], memo)
+        lexer_conf.callbacks = options.lexer_callbacks or {}
+        lexer_conf.re_module = regex if options.regex else re
+        lexer_conf.use_bytes = options.use_bytes
+        lexer_conf.g_regex_flags = options.g_regex_flags
+        lexer_conf.skip_validation = True
+        lexer_conf.postlex = options.postlex
+        return lexer_conf
+
+    def _load(self: _T, f: Any, **kwargs) -> _T:
+        if isinstance(f, dict):
+            d = f
+        else:
+            d = pickle.load(f)
+        memo_json = d["memo"]
+        data = d["data"]
+
+        assert memo_json
+        memo = SerializeMemoizer.deserialize(
+            memo_json, {"Rule": Rule, "TerminalDef": TerminalDef}, {}
+        )
+        options = dict(data["options"])
+        if (set(kwargs) - _LOAD_ALLOWED_OPTIONS) & set(LarkOptions._defaults):
+            raise ConfigurationError(
+                "Some options are not allowed when loading a Parser: {}".format(
+                    set(kwargs) - _LOAD_ALLOWED_OPTIONS
+                )
+            )
+        options.update(kwargs)
+        self.options = LarkOptions.deserialize(options, memo)
+        self.rules = [Rule.deserialize(r, memo) for r in data["rules"]]
+        self.source_path = "<deserialized>"
+        _validate_frontend_args(self.options.parser, self.options.lexer)
+        self.lexer_conf = self._deserialize_lexer_conf(
+            data["parser"], memo, self.options
+        )
+        self.terminals = self.lexer_conf.terminals
+        self._prepare_callbacks()
+        self._terminals_dict = {t.name: t for t in self.terminals}
+        self.parser = _deserialize_parsing_frontend(
+            data["parser"],
+            memo,
+            self.lexer_conf,
+            self._callbacks,
+            self.options,  ##
+
+        )
+        return self
+
+    @classmethod
+    def _load_from_dict(cls, data, memo, **kwargs):
+        inst = cls.__new__(cls)
+        return inst._load({"data": data, "memo": memo}, **kwargs)
+
+    @classmethod
+    def open(
+        cls: Type[_T], grammar_filename: str, rel_to: Optional[str] = None, **options
+    ) -> _T:
+        #--
+        if rel_to:
+            basepath = os.path.dirname(rel_to)
+            grammar_filename = os.path.join(basepath, grammar_filename)
+        with open(grammar_filename, encoding="utf8") as f:
+            return cls(f, **options)
+
+    @classmethod
+    def open_from_package(
+        cls: Type[_T],
+        package: str,
+        grammar_path: str,
+        search_paths: "Sequence[str]" = [""],
+        **options
+    ) -> _T:
+        #--
+        package_loader = FromPackageLoader(package, search_paths)
+        full_path, text = package_loader(None, grammar_path)
+        options.setdefault("source_path", full_path)
+        options.setdefault("import_paths", [])
+        options["import_paths"].append(package_loader)
+        return cls(text, **options)
+
+    def __repr__(self):
+        return "Lark(open(%r), parser=%r, lexer=%r, ...)" % (
+            self.source_path,
+            self.options.parser,
+            self.options.lexer,
+        )
+
+    def lex(self, text: str, dont_ignore: bool = False) -> Iterator[Token]:
+        #--
+        lexer: Lexer
+        if not hasattr(self, "lexer") or dont_ignore:
+            lexer = self._build_lexer(dont_ignore)
+        else:
+            lexer = self.lexer
+        lexer_thread = LexerThread.from_text(lexer, text)
+        stream = lexer_thread.lex(None)
+        if self.options.postlex:
+            return self.options.postlex.process(stream)
+        return stream
+
+    def get_terminal(self, name: str) -> TerminalDef:
+        #--
+        return self._terminals_dict[name]
+
+    def parse_interactive(
+        self, text: Optional[str] = None, start: Optional[str] = None
+    ) -> "InteractiveParser":
+        #--
+        return self.parser.parse_interactive(text, start=start)
+
+    def parse(
+        self,
+        text: str,
+        start: Optional[str] = None,
+        on_error: "Optional[Callable[[UnexpectedInput], bool]]" = None,
+    ) -> "ParseTree":
+        #--
+        return self.parser.parse(text, start=start, on_error=on_error)
+
+
+
+
+
+class DedentError(LarkError):
+    pass
+
+
+class Indenter(PostLex, ABC):
+    paren_level: int
+    indent_level: List[int]
+
+    def __init__(self) -> None:
+        self.paren_level = 0
+        self.indent_level = [0]
+        assert self.tab_len > 0
+
+    def handle_NL(self, token: Token) -> Iterator[Token]:
+        if self.paren_level > 0:
+            return
+
+        yield token
+
+        indent_str = token.rsplit("\n", 1)[1]  ##
+
+        indent = indent_str.count(" ") + indent_str.count("\t") * self.tab_len
+
+        if indent > self.indent_level[-1]:
+            self.indent_level.append(indent)
+            yield Token.new_borrow_pos(self.INDENT_type, indent_str, token)
+        else:
+            while indent < self.indent_level[-1]:
+                self.indent_level.pop()
+                yield Token.new_borrow_pos(self.DEDENT_type, indent_str, token)
+
+            if indent != self.indent_level[-1]:
+                raise DedentError(
+                    "Unexpected dedent to column %s. Expected dedent to %s"
+                    % (indent, self.indent_level[-1])
+                )
+
+    def _process(self, stream):
+        for token in stream:
+            if token.type == self.NL_type:
+                yield from self.handle_NL(token)
+            else:
+                yield token
+
+            if token.type in self.OPEN_PAREN_types:
+                self.paren_level += 1
+            elif token.type in self.CLOSE_PAREN_types:
+                self.paren_level -= 1
+                assert self.paren_level >= 0
+
+        while len(self.indent_level) > 1:
+            self.indent_level.pop()
+            yield Token(self.DEDENT_type, "")
+
+        assert self.indent_level == [0], self.indent_level
+
+    def process(self, stream):
+        self.paren_level = 0
+        self.indent_level = [0]
+        return self._process(stream)
+
+    ##
+
+    @property
+    def always_accept(self):
+        return (self.NL_type,)
+
+    @property
+    @abstractmethod
+    def NL_type(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def OPEN_PAREN_types(self) -> List[str]:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def CLOSE_PAREN_types(self) -> List[str]:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def INDENT_type(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def DEDENT_type(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    @abstractmethod
+    def tab_len(self) -> int:
+        raise NotImplementedError()
+
+
+class PythonIndenter(Indenter):
+    NL_type = "_NEWLINE"
+    OPEN_PAREN_types = ["LPAR", "LSQB", "LBRACE"]
+    CLOSE_PAREN_types = ["RPAR", "RSQB", "RBRACE"]
+    INDENT_type = "_INDENT"
+    DEDENT_type = "_DEDENT"
+    tab_len = 8
+
+
+
+import pickle, zlib, base64
+DATA = (
+b'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'
+)
+DATA = pickle.loads(zlib.decompress(base64.b64decode(DATA)))
+MEMO = (
+b'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'
+)
+MEMO = pickle.loads(zlib.decompress(base64.b64decode(MEMO)))
+Shift = 0
+Reduce = 1
+def Lark_StandAlone(**kwargs):
+  return Lark._load_from_dict(DATA, MEMO, **kwargs)