jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/compiler/larkparse/jac_parser.py

@@ -0,0 +1,3444 @@
+# The file was automatically generated by Lark v1.2.2
+__version__ = "1.2.2"
+
+#
+#
+#   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)
+
+
+
+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 = dict()
+        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:
+        #--
+        res = list(self._transform_children([tree]))
+        if not res:
+            return None     ##
+
+        assert len(res) == 1
+        return res[0]
+
+    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 = u'|'.join(u'(?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 self.copy()
+
+    def copy(self, deepcopy_values=True) -> 'ParserState[StateT]':
+        return type(self)(
+            self.parse_conf,
+            self.lexer, ##
+
+            copy(self.state_stack),
+            deepcopy(self.value_stack) if deepcopy_values else copy(self.value_stack),
+        )
+
+    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: ParserState, 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 self.copy()
+
+    def copy(self, deepcopy_values=True):
+        return type(self)(
+            self.parser,
+            self.parser_state.copy(deepcopy_values=deepcopy_values),
+            copy(self.lexer_thread),
+        )
+
+    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 = self.copy(deepcopy_values=False)
+                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 grammar.isascii():
+                    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)