Edit File: lexer.cpython-311.pyc
� ������Fh{v���������������������������d�Z�ddlZddlmZ�ddlmZ�ddlmZ�ddlm Z �ddlm Z �dd lmZ�dd lmZ�ddl mZ�ddlmZ��ed ������������Z�ej��������dej��������������������Z�ej��������d������������Z�ej��������dej��������������������Z�ej��������d������������Z�ej��������dej��������ej��������z��������������Z ��eddd�������������ddlmZ�dZn#�e $�r��ej��������d������������ZdZY�nw�xY�w�e d������������Z!�e d������������Z"�e d������������Z#�e d������������Z$�e d������������Z%�e d������������Z&�e d ������������Z'�e d!������������Z(�e d"������������Z)�e d#������������Z*�e d$������������Z+�e d%������������Z,�e d&������������Z-�e d'������������Z.�e d(������������Z/�e d)������������Z0�e d*������������Z1�e d+������������Z2�e d,������������Z3�e d-������������Z4�e d.������������Z5�e d/������������Z6�e d0������������Z7�e d1������������Z8�e d2������������Z9�e d3������������Z:�e d4������������Z;�e d5������������Z<�e d6������������Z=�e d7������������Z>�e d8������������Z?�e d9������������Z@�e d:������������ZA�e d;������������ZB�e d<������������ZC�e d=������������ZD�e d>������������ZE�e d?������������ZF�e d@������������ZG�e dA������������ZH�e dB������������ZI�e dC������������ZJ�e dD������������ZK�e dE������������ZL�e dF������������ZM�e dG������������ZN�e dH������������ZO�e dI������������ZP�e dJ������������ZQi�dKe!�dLe9�dMe%�dNe(�dOe1�dPe0�dQe4�dRe:�dSe,�dTe6�dUe-�dVe7�dWe+�dXe5�dYe'�dZe2�d[e)�e*e.e/e"e&e#e3e$e8d\� �ZR�eSd]���eeR������������D���������������������������ZT�eUeR�������������eUeT������������k����s J�d^����������������ej��������d_d`�V��������������������da���eWeRdb���c������������D���������������������������z��������������ZX�eYeGeIeHe;eLeMeNg������������ZZ�eYe;eOeIeNg������������Z[dd��Z\de��Z]df��Z^dg��Z_dh��Z`�G�di��djea������������Zb�G�dk��dlec������������Zde �G�dm��dnea��������������������������Zee �G�do��dpea��������������������������Zfdq��Zg�G�dr��dsec������������Zh�G�dt��duea������������ZidS�)vz�Implements a Jinja / Python combination lexer. The ``Lexer`` class is used to do some preprocessing. It filters out invalid operators like the bitshift operators we don't allow in templates. It separates template code and python code in expressions. �����N)�literal_eval)�deque)� itemgetter����)�implements_iterator)�intern)� iteritems)� text_type)�TemplateSyntaxError)�LRUCache�2���z\s+z(\r\n|\r|\n)z7('([^'\\]*(?:\\.[^'\\]*)*)'|"([^"\\]*(?:\\.[^"\\]*)*)")z (\d+_)*\d+z� (?<!\.) # doesn't start with a . (\d+_)*\d+ # digits, possibly _ separated ( (\.(\d+_)*\d+)? # optional fractional part e[+\-]?(\d+_)*\d+ # exponent part | \.(\d+_)*\d+ # required fractional part ) u���fööz <unknown>�eval)�patternTz[a-zA-Z_][a-zA-Z0-9_]*F�add�assign�colon�comma�div�dot�eq�floordiv�gt�gteq�lbrace�lbracket�lparen�lt�lteq�mod�mul�ne�pipe�pow�rbrace�rbracket�rparen� semicolon�sub�tilde� whitespace�float�integer�name�string�operator�block_begin� block_end�variable_begin�variable_end� raw_begin�raw_end� comment_begin�comment_end�comment�linestatement_begin�linestatement_end�linecomment_begin�linecomment_end�linecomment�data�initial�eof�+�-�/z//�*�%z**�~�[�]�(�)�{�}z==z!=�>) z>=�<z<=�=�.�:�|�,�;c�����������������������g�|�] \��}}||f�� S���rV���)�.0�k�vs��� �l/builddir/build/BUILD/imunify360-venv-2.5.3/opt/imunify360/venv/lib/python3.11/site-packages/jinja2/lexer.py� <listcomp>r[�������s ������B�B�B�T�Q��1�a�&�B�B�B�����zoperators droppedz(%s)rR���c��������������#����>���K����|�]}t����������j��������|������������V����d�S��N)�re�escape�rW����xs��� rZ���� <genexpr>rc�������s*����������U�U�q�b�i��l�l�U�U�U�U�U�Ur\���c������������������"�����t����������|��������������S�r^���)�len�rb���s��� rZ����<lambda>rg�������s������S�QR�V�V�G��r\���)�keyc����������������������|�t�����������v�r t�����������|����������S�t����������dt����������dt����������dt����������dt ����������dt����������dt����������dt����������dt����������dt����������d t����������d t����������di� ��������������������|�|�������������S�)Nzbegin of commentzend of commentr8���zbegin of statement blockzend of statement blockzbegin of print statementzend of print statementzbegin of line statementzend of line statementztemplate data / textzend of template)�reverse_operators�TOKEN_COMMENT_BEGIN�TOKEN_COMMENT_END� TOKEN_COMMENT�TOKEN_LINECOMMENT�TOKEN_BLOCK_BEGIN�TOKEN_BLOCK_END�TOKEN_VARIABLE_BEGIN�TOKEN_VARIABLE_END�TOKEN_LINESTATEMENT_BEGIN�TOKEN_LINESTATEMENT_END� TOKEN_DATA� TOKEN_EOF�get)� token_types��� rZ����_describe_token_typery�������sz�������&�&�&� ��,�,��/��+��y��9��5��1��8��4�!�#<��!8��*��$� �� �c�*�j�!�!� "r\���c������������������X�����|�j���������t����������k����r|�j��������S�t����������|�j���������������������S�)z#Returns a description of the token.)�type� TOKEN_NAME�valuery���)�tokens��� rZ����describe_tokenr�������s'�������z�Z����{���� �+�+�+r\���c������������������z�����d|�v�r'|�����������������������dd������������\��}}|t����������k����r|S�n|�}t����������|������������S�)z0Like `describe_token` but for token expressions.rQ���r���)�splitr|���ry���)�exprr{���r}���s��� rZ����describe_token_exprr��������sL������ �d�{�{��j�j��a�(�(���e��:����L��������%�%�%r\���c������������������P�����t����������t�������������������������������|�������������������������S�)zsCount the number of newline characters in the string. This is useful for extensions that filter a stream. )re���� newline_re�findall)r}���s��� rZ����count_newlinesr��������s ��������z�!�!�%�(�(�)�)�)r\���c������������������f����t�����������j��������}t����������|�j��������������������t�����������||�j��������������������ft����������|�j��������������������t�����������||�j��������������������ft����������|�j��������������������t�����������||�j��������������������fg}|�j ���������@|� ��������������������t����������|�j ��������������������t����������d�||�j ��������������������z���f�������������|�j���������@|� ��������������������t����������|�j��������������������t����������d�||�j��������������������z���f�������������d��t����������|d�������������D���������������S�)zACompiles all the rules from the environment into a list of rules.Nz ^[ \t\v]*z(?:^|(?<=\S))[^\S\r\n]*c������������������"�����g�|�]}|d�d������������ S�)r���NrV���ra���s��� rZ���r[���z!compile_rules.<locals>.<listcomp>����s ������7�7�7�a�A�a�b�b�E�7�7�7r\���T)�reverse)r_���r`���re����comment_start_stringrk����block_start_stringro����variable_start_stringrq����line_statement_prefix�appendrs����line_comment_prefix�TOKEN_LINECOMMENT_BEGIN�sorted)�environment�e�ruless��� rZ���� compile_rulesr��������sC����� � �A�� ��0�1�1�� �A�k�.�/�/� �� ��.�/�/�� �A�k�,�-�-� �� ��1�2�2� � �A�k�/�0�0� � �E�$��(�4� ����K�5�6�6�)��q�q��!B�C�C�C� � �� �� ���&�2� ����K�3�4�4�'�*�Q�Q�{�/N�-O�-O�O� � �� �� ��8�7�6�%��6�6�6�7�7�7�7r\���c��������������������"�����e�Zd�ZdZefd�Zd��ZdS�)�FailurezjClass that raises a `TemplateSyntaxError` if called. Used by the `Lexer` to specify known errors. c������������������"�����||�_���������||�_��������d�S�r^���)�message�error_class)�selfr�����clss��� rZ����__init__zFailure.__init__����s�������������r\���c������������������:�����|�����������������������|�j��������||�������������r^���)r����r����)r�����lineno�filenames��� rZ����__call__zFailure.__call__����s���������t�|�V�X�>�>�>r\���N)�__name__� __module__�__qualname__�__doc__r���r����r����rV���r\���rZ���r����r��������sF������������������%8���������?��?��?��?��?r\���r����c��������������������f�����e�Zd�ZdZdZd���ed������������D���������������\��ZZZd��Z d��Z d��Zd��Zd ��Z d S�)�TokenzToken class.rV���c��������������#����N���K����|�] }t����������t����������|������������������������V����!d�S�r^���)�propertyr���ra���s��� rZ���rc���zToken.<genexpr>��s0����������E�E�q�8�J�q�M�M�2�2�E�E�E�E�E�Er\�������c����������� �������r�����t��������������������������������|�|t����������t����������|������������������������|f������������S�r^���)�tuple�__new__r����str)r����r����r{���r}���s��� rZ���r����z Token.__new__ ��s+�������}�}�S�6�6�#�d�)�)�+<�+<�e�"D�E�E�Er\���c������������������t�����|�j���������t����������v�rt����������|�j������������������S�|�j���������dk����r|�j��������S�|�j���������S�)Nr-���)r{���rj���r}����r����s��� rZ����__str__z Token.__str__��s:�������9�)�)�)�$�T�Y�/�/� �Y�&� � ��:���y�r\���c������������������t�����|�j���������|k����rdS�d|v�r&|���������������������dd������������|�j���������|�j��������gk����S�dS�)z�Test a token against a token expression. This can either be a token type or ``'token_type:token_value'``. This can only test against string values and types. TrQ���r���F)r{���r����r}����r����r����s��� rZ����testz Token.test��sF��������9�����4� �D�[�[��:�:�c�1�%�%�$�)�T�Z�)@�@�@��ur\���c������������������@�����|D�]}|�����������������������|������������r�dS��dS�)z(Test against multiple token expressions.TF)r����)r�����iterabler����s��� rZ����test_anyzToken.test_any ��s4�������� �� �D��y�y����� ��t�t� ��ur\���c������������������8�����d|�j����������d|�j���������d|�j���������d�S�)NzToken(z, rJ���)r����r{���r}���r����s��� rZ����__repr__zToken.__repr__'��s#��������&*�k�k�k�4�9�9�9�d�j�j�j�I�Ir\���N)r����r����r����r����� __slots__�ranger����r{���r}���r����r����r����r����r����rV���r\���rZ���r����r������s������������������I�E�E�E�E�!�H�H�E�E�E��F�D�%�F��F��F����������������J��J��J��J��Jr\���r����c��������������������$�����e�Zd�ZdZd��Zd��Zd��ZdS�)�TokenStreamIteratorz`The iterator for tokenstreams. Iterate over the stream until the eof token is reached. c�����������������������||�_���������d�S�r^���)�stream)r����r����s��� rZ���r����zTokenStreamIterator.__init__1��s ����������r\���c�����������������������|�S�r^���rV���r����s��� rZ����__iter__zTokenStreamIterator.__iter__4��s�������r\���c�����������������������|�j���������j��������}|j��������t����������u�r'|�j���������������������������������������������t�������������������������t ����������|�j����������������������|S�r^���)r�����currentr{���rv����close� StopIteration�next�r����r~���s��� rZ����__next__zTokenStreamIterator.__next__7��sL��������#���:��"�"��K�������/�/�!��T�[�����r\���N)r����r����r����r����r����r����r����rV���r\���rZ���r����r����+��sK�����������������������������������r\���r����c��������������������p�����e�Zd�ZdZd��Zd��Zd��ZeZed����������������Z d��Z d��Zdd �Zd ��Z d��Zd��Zd ��Zd��ZdS�)�TokenStreamz�A token stream is an iterable that yields :class:`Token`\s. The parser however does not iterate over it but calls :meth:`next` to go one token ahead. The current active token is stored as :attr:`current`. c������������������������t����������|������������|�_��������t������������������������|�_��������||�_��������||�_��������d|�_��������t����������dt����������d������������|�_ ��������t����������|��������������d�S�)NFr�����)�iter�_iterr����_pushedr-���r�����closedr����� TOKEN_INITIALr����r����)r����� generatorr-���r����s��� rZ���r����zTokenStream.__init__G��sQ�������)�_�_�� ��w�w����� � �� �����Q� �r�2�2����T� � � � � r\���c������������������ �����t����������|�������������S�r^���)r����r����s��� rZ���r����zTokenStream.__iter__P��s������"�4�(�(�(r\���c������������������P�����t����������|�j��������������������p|�j��������j��������t����������uS�r^���)�boolr����r����r{���rv���r����s��� rZ����__bool__zTokenStream.__bool__S��s!�������D�L�!�!�G�T�\�%6�i�%G�Gr\���c�����������������������|��S�)z Are we at the end of the stream?rV���r����s��� rZ����eoszTokenStream.eosX��s��������x�r\���c������������������:�����|�j������������������������������|�������������dS�)z Push a token back to the stream.N)r����r����r����s��� rZ����pushzTokenStream.push]��s����������E�"�"�"�"�"r\���c������������������j�����t����������|�������������}|�j��������}|����������������������|�������������||�_��������|S�)zLook at the next token.)r����r����r����)r����� old_token�results��� rZ����lookzTokenStream.looka��s2��������J�J� ����� � �&���� ���� r\���r���c������������������H�����t����������|������������D�]}t����������|���������������dS�)zGot n tokens ahead.N)r����r����)r�����n�_s��� rZ����skipzTokenStream.skipi��s.�������q���� �� �A���J�J�J�J� �� r\���c������������������X�����|�j������������������������������|������������rt����������|�������������S�dS�)zqPerform the token test and return the token if it matched. Otherwise the return value is `None`. N)r����r����r����r����s��� rZ����next_ifzTokenStream.next_ifn��s2��������<���T�"�"�� ���:�:�� �� r\���c������������������0�����|�����������������������|������������duS�)z8Like :meth:`next_if` but only returns `True` or `False`.N)r����r����s��� rZ����skip_ifzTokenStream.skip_ifu��s�������|�|�D�!�!��-�-r\���c����������������������|�j���������}|�j��������r|�j�������������������������������������������|�_���������nR|�j���������j��������t����������ur? �t����������|�j��������������������|�_���������n$#�t����������$�r�|�������������������������������������Y�nw�xY�w|S�)z|Go one token ahead and return the old one. Use the built-in :func:`next` instead of calling this directly. ) r����r�����popleftr{���rv���r����r����r����r����)r�����rvs��� rZ���r����zTokenStream.__next__y��s������� ��\���<�� ��<�/�/�1�1�D�L�L� �\� �i� /� /� �#�D�J�/�/����� �� �� �� �� � ������ ����� s����A��A=�<A=c������������������l�����t����������|�j��������j��������t����������d������������|�_��������d|�_��������d|�_��������dS�)zClose the stream.r����NT)r����r����r����rv���r����r����r����s��� rZ���r����zTokenStream.close���s,�������T�\�0�)�R�@�@����� �����r\���c����������������������|�j������������������������������|������������s�t����������|������������}|�j���������j��������t����������u�r)t����������d|z��|�j���������j��������|�j��������|�j���������������������t����������d|�dt����������|�j�����������������������|�j���������j��������|�j��������|�j��������������������� �|�j���������t����������|��������������S�#�t����������|��������������w�xY�w)z}Expect a given token type and return it. This accepts the same argument as :meth:`jinja2.lexer.Token.test`. z(unexpected end of template, expected %r.zexpected token z, got )r����r����r����r{���rv���r���r����r-���r����r���r����r����s��� rZ����expectzTokenStream.expect���s���������|� � ��&�&�� �&�t�,�,�D��|� �I�-�-�)�>��E��L�'��I��M� ������&�%�/3�t�t�^�D�L�5Q�5Q�5Q�R���#�� �� � ���� � ��<���J�J�J�J��D��J�J�J�J���s����%B;��;CN)r���)r����r����r����r����r����r����r�����__nonzero__r����r����r����r����r����r����r����r����r����r����rV���r\���rZ���r����r����@��s������������������ �����)��)��)�H��H��H���K� ������X��#��#��#������������� �����.��.��.� �� �� ��������������r\���r����c����������������������|�j���������|�j��������|�j��������|�j��������|�j��������|�j��������|�j��������|�j��������|�j��������|�j ��������|�j ��������|�j��������f}t����������� ��������������������|������������}|�t����������|�������������}|t����������|<���|S�)z(Return a lexer which is probably cached.)r�����block_end_stringr�����variable_end_stringr�����comment_end_stringr����r�����trim_blocks� lstrip_blocks�newline_sequence�keep_trailing_newline�_lexer_cacherw����Lexer)r����rh����lexers��� rZ���� get_lexerr�������s�������� �&��$��)��'��(��&��)��'����!��$��)� �C�� ���S�!�!�E��}��k�"�"��!��S���Lr\���c��������������������&�������e�Zd�ZdZdZ��fd�Z��xZS�)�OptionalLStripzWA special tuple for marking a point in the state that can have lstrip applied. rV���c������������������V������t����������t����������|����������������������������������|�|������������S�r^���)�superr����r����)r�����members�kwargs� __class__s��� �rZ���r����zOptionalLStrip.__new__���s#��������^�S�)�)�1�1�#�w�?�?�?r\���)r����r����r����r����r����r����� __classcell__)r��s���@rZ���r����r�������sR��������������������I�@��@��@��@��@��@��@��@��@r\���r����c��������������������6�����e�Zd�ZdZd��Zd��Zdd�Zd d�Zd d�ZdS�) r����a ��Class that implements a lexer for a given environment. Automatically created by the environment class, usually you don't have to do that. Note that the lexer is not automatically bound to an environment. Multiple environments can share the same lexer. c����������������������t�����������j��������}d��}t����������t����������d�ft����������t ����������d�ft����������t����������d�ft����������t����������d�ft����������t����������d�ft����������t����������d�fg}t����������|������������}|j��������rdpd}|j��������r�|d������������nd�|�_��������|j��������|�_��������|j��������|�_��������d�|dd���������������������d�||j���������������������d �||j���������������������d �||j���������������������d�gd��|D���������������z���������������z��������������t/����������t0����������d ������������d f�|d������������t0����������d�fgt2�����������|d�||j���������������������d �||j���������������������d|�d�������������t6����������t8����������fdf�|d������������t;����������d������������fd�fgt<�����������|d�||j���������������������d �||j���������������������d|��������������t>����������dfg|z���t@�����������|d�||j!���������������������d �||j!����������������������������������tD����������dfg|z���tF�����������|d�||j���������������������d�||j���������������������d �||j���������������������|�d�������������t/����������t0����������tH����������������������df�|d������������t;����������d������������fd�fgtJ�����������|d������������tL����������dfg|z���tN�����������|d������������tP����������tR����������fdfgi|�_*��������d�S�)Nc������������������Z�����t����������j��������|�t�����������j��������t�����������j��������z��������������S�r^���)r_����compile�M�Srf���s��� rZ����czLexer.__init__.<locals>.c���s�������:�a������-�-�-r\���z\n?r����z[^ \t]�rootz(.*?)(?:%s)rR���z(?P<raw_begin>z(\-|\+|)\s*raw\s*(?:\-z\s*|z))c������������������&�����g�|�]\��}}d�|�d|�d���S�)z(?P<rM���z (\-|\+|))rV���)rW���r�����rs��� rZ���r[���z"Lexer.__init__.<locals>.<listcomp>��s;������������$(�A�q�q��:;���A�A�A� >�����r\����#bygroupz.+z(.*?)((?:\-rJ����#popz(.)zMissing end of comment tagz(?:\-z\-z (.*?)((?:z(\-|\+|))\s*endraw\s*(?:\-zMissing end of raw directivez \s*(\n|$)z(.*?)()(?=\n|$))+r_���r`���� whitespace_re�TOKEN_WHITESPACE�float_re�TOKEN_FLOAT� integer_re� TOKEN_INTEGER�name_rer|���� string_re�TOKEN_STRING�operator_re�TOKEN_OPERATORr����r����r�����lstrip_unless_rer����r�����joinr����r����r����ru���rk���r����rm���rl���r����ro���rp���rq���r����rr����TOKEN_RAW_BEGIN� TOKEN_RAW_ENDrs���rt���r����rn����TOKEN_LINECOMMENT_ENDr����)r����r����r����r ��� tag_rules�root_tag_rules�block_suffix_res��� rZ���r����zLexer.__init__���s�������I�� .�� .�� .� ��,�d�3� �{�D�)� ���-� �j�$�'� ��d�+� �.�$�/� � ��'�{�3�3���&�1�<�f�B����1<�0I� S���)����t��� +� <���%0�%F��"�� ���A�%��(�(�(��%&�A�k�&D�$E�$E�$E�$E�$%�A�k�&B�$C�$C�$C�$C�$%�A�k�&B�$C�$C�$C�$C� !"�����,:������� �� �����"�#�:�z�:�:��'�,���4���*�d�+�1�6� ��A�A���A�k�<�=�=�=�=��A�k�<�=�=�=�=�+�O�O� �����#�$5�6������5���G�$@�A�A�C�T�J�"� � ��A�A���A�k�:�;�;�;�;��A�k�:�;�;�;�;�+�O� �����$��� ��� � � !��A�A���A�k�=�>�>�>�>��A�k�=�>�>�>������'�� �#��� #�� ��A�A���A�k�<�=�=�=�=��A�k�:�;�;�;�;��A�k�:�;�;�;�+�O�O������#�:�}�=�=������5���G�$B�C�C�E�t�L��"� &���<���"9�6�B�(���(� � $��A�(�)�)�&�(=�>���&�Ch �� � � r\���c������������������B�����t��������������������������������|�j��������|������������S�)z@Called for strings and template data to normalize it to unicode.)r����r(���r����)r����r}���s��� rZ����_normalize_newlineszLexer._normalize_newlinesa��s�������~�~�d�3�U�;�;�;r\���Nc������������������~�����|�����������������������||||������������}t����������|����������������������|||������������||������������S�)z:Calls tokeniter + tokenize and wraps it in a token stream.)� tokeniterr�����wrap)r�����sourcer-���r�����stater����s��� rZ����tokenizezLexer.tokenizee��s;�����������h��>�>���4�9�9�V�T�8�<�<�d�H�M�M�Mr\���c��������������#�������K����|D��]�\��}}}|t�����������v�r�|t����������k����r t����������}�n�|t����������k����r t����������}�n�|t ����������t����������fv�r�J|t����������k����r|����������������������|������������}�nx|dk����r|}�nn|t����������k����r>t����������|������������}t����������r&|�����������������������������������st����������d|||��������������n%|t����������k����r� �|����������������������|dd�������������������������������������������dd���������������������������������d������������}n�#�t"����������$�rQ}t����������|���������������������������������d������������d��������������������������������������������}t����������||||�������������d }~ww�xY�w|t(����������k����r$t+����������|���������������������d d������������������������}nG|t.����������k����r$t1����������|���������������������d d������������������������}n|t2����������k����r t4����������|���������}t7����������|||������������V������d S�)z�This is called with the stream as returned by `tokenize` and wraps every token in a :class:`Token` and converts the value. �keywordzInvalid character in identifierr�������ascii�backslashreplacezunicode-escaperQ���Nr����r����)�ignored_tokensrs���ro���rt���rp���r��r��ru���r#��r|���r�����check_ident�isidentifierr���r���encode�decode� Exceptionr�����stripr���int�replacer��r���r��� operatorsr����) r����r����r-���r����r����r~���r}���r�����msgs ��� rZ���r&��z Lexer.wrapj��s#����������%+��& .��& .� �F�E�5���&�&���3�3�3�)����1�1�1�'����?�M�:�:�:���*�$�$��0�0��7�7����)�#�#�����*�$�$��E� � �����u�'9�'9�';�';���-�9�6�4����������,�&�&�K��0�0��q��t��=�=����);�<�<��� 0�1�1���E�� �!��K��K��K��a�&�&�,�,�s�+�+�B�/�5�5�7�7�C�-�c�6�4��J�J�J�����K������-�'�'��E�M�M�#�r�2�2�3�3����+�%�%�$�U�]�]�3��%;�%;�<�<����.�(�(�!�%�(�����u�-�-�-�-�-�-�M& .��& .s����AD� E0�AE+�+E0c��������������#����8 ��K����t����������|������������}|�����������������������������������}|�j��������r3|r1dD�].}|���������������������|������������r|���������������������d��������������n�/d���������������������|������������}d}d}dg} |�,|dk����r&|dv�s J�d ���������������| ���������������������|d z����������������|�j��������| d������������������} t����������|������������}g�}|�j��������} d}d} �| D��]\��}}}|� ��������������������||������������}|�� |r|t����������t����������t����������fv�r�9t����������|t�����������������������r�|�����������������������������������}t����������|t ����������������������r�|d���������}t#����������d ��|ddd����������D���������������������������}|dk����rM|�����������������������������������}|t����������|������������d�������������������������������d������������}|f|dd����������z���}n�|dk����rz| �x|��������������������������������������������������������t,����������������������sL|���������������������d������������dz���}|dk����s|r,| ���������������������||������������s|d|����������f|dd����������z���}t3����������|������������D�]�\��}}|j��������t6����������u�r�|||�������������|dk����r]t9����������|�����������������������������������������������D�](\��}}|�!|||fV���||���������������������d������������z ��}�n�)t;����������d|z�����������������||���������}|s |t<����������vr|||fV���||���������������������d������������|z���z ��}d}��n�|�����������������������������������}|t@����������k����r�|dk����r|���������������������d�������������n�|dk����r|���������������������d�������������nj|dk����r|���������������������d�������������nN|dv�rJ|stC����������d|z��|||�������������|�"����������������������������������}||k����rtC����������d|�d|�d�|||�������������|s |t<����������vr|||fV���||���������������������d������������z ��}|�����������������������������������dd����������dk����}|�#����������������������������������}|��|dk����r| �"�����������������������������������nn|dk����rSt9����������|�����������������������������������������������D�]\��}}|�| ���������������������|��������������n�t;����������d|z���������������n| ���������������������|�������������|�j��������| d������������������} n||k����rt;����������d |z���������������|}�n%||k����rdS�tC����������d!||���������|fz��|||���������������B)"z�This method tokenizes the text and returns the tokens in a generator. Use this method if you just want to tokenize a template. )z � � r����r<��r���r���r ��N)�variable�blockz invalid state�_beginr,��Tc��������������3�������K����|�]}|�|V���� d�S�r^���rV���)rW����gs��� rZ���rc���z"Lexer.tokeniter.<locals>.<genexpr>���s"����������)S�)S��Q�]�!�]�]�]�]�)S�)Sr\�������rB���rA���r ��z?%r wanted to resolve the token dynamically but no group matchedrK���rL���rI���rJ���rG���rH���)rL���rJ���rH���zunexpected '%s'zunexpected 'z ', expected '�'r��zC%r wanted to resolve the new state dynamically but no group matchedz,%r yielded empty string without stack changezunexpected char %r at %d)$r ���� splitlinesr�����endswithr����r��r����re���r���matchrr���rp���rt���� isinstancer�����groupsr����r�����rstrip�count� groupdictrw���rq����rfind�search� enumerater��r����r ����RuntimeError�ignore_if_empty�groupr��r����pop�end) r����r'��r-���r����r(���lines�newline�posr�����stack�statetokens� source_length�balancing_stackr���newlines_stripped� line_starting�regex�tokens� new_state�mrH���text� strip_sign�stripped�l_pos�idxr~���rh���r}���r>����expected_op�pos2s ��� rZ���r%��zLexer.tokeniter���sq�����������6�"�"���!�!�#�#���%�� �&�� �/�� �� ���?�?�7�+�+����L�L��$�$�$��E������5�!�!������������&����1�1�1�1�?�1�1�1��L�L���)�*�*�*��j��r��+���F��� ����0����� �a �,7��_ ��_ �(��v�y��K�K���,�,���9���#���v�&�#�+�2��(��(� ����f�e�,�,��Y/��X�X�Z�Z�F�!�&�.�9�9��J�� &�a�y�� �&*�)S�)S�V�A�D�q�D�\�)S�)S�)S�%S�%S� �%��,�,�'+�{�{�}�}�H�04�S��]�]�_�_�0E�0K�0K�D�0Q�0Q�-�&.�[�6�!�"�"�:�%=�F�F��'�#�-�-� 0� <�$%�K�K�M�M�$5�$5�6J�$K�$K��!=� �%)�J�J�t�$4�$4�q�$8�E�$�q�y�y�M�y��(8�'>�'>�t�U�'K�'K��!J�.2�6�E�6�l�_�v�a�b�b�z�-I�F�&/��&7�&7��2��2� ��U� �?�g�5�5�"'�%���"9�"9�9��#�j�0�0�.7���� � �.F�.F�� "�� "� ��U�#(�#4�*0�#�u�*<�$<�$<�$<�$*�e�k�k�$�.?�.?�$?�F�$)�E��$5� �'3�%<�>C�%D�'"��'"��!"��%*��$*�#�;�D�#��:�u�O�'C�'C�&,�e�T�&9� 9� 9� 9�"�d�j�j��&6�&6�9J�&J�J�F�01�-�-�32�:��7�7�9�9�D���/�/��3�;�;�+�2�2�3�7�7�7�7�!�S�[�[�+�2�2�3�7�7�7�7�!�S�[�[�+�2�2�3�7�7�7�7�!�_�4�4�#2��"�&9�$5��$<�f�d�H�'"��'"��!"��+:�*=�*=�*?�*?�K�*�d�2�2�&9�&9�7;�t�t�[�[�[�%J�$*�$(�$,�'"��'"��!"����3�v�_�<�<�$�f�d�2�2�2�2��d�j�j��.�.�.�F� !��� � �"�#�#��$� 6� � ��u�u�w�w����(� �F�*�*�� � �����"�j�0�0�*3�A�K�K�M�M�*B�*B�� �� �J�C��$�0� %���S� 1� 1� 1� %��� 1��#/�!4�6;�!<�#��#����!&�����Y�/�/�/�"&�*�U�2�Y�"7�K�K���S�[�[�&�F��N����������� ��-�'�'��F�)�.�&��+�s�1C�C���� �����ya r\���)NNN)NN) r����r����r����r����r����r#��r)��r&��r%��rV���r\���rZ���r����r�������s������������������L ��L ��L �\<��<��<�N��N��N��N� *.��*.��*.��*.�Xz��z��z��z��z��zr\���r����)jr����r_����astr����collectionsr���r/���r����_compatr���r���r ���r ���� exceptionsr����utilsr���r����r���Ur��r����r��r��r��� IGNORECASE�VERBOSEr���_identifierr���r��r0���SyntaxError� TOKEN_ADD�TOKEN_ASSIGN�TOKEN_COLON�TOKEN_COMMA� TOKEN_DIV� TOKEN_DOT�TOKEN_EQ�TOKEN_FLOORDIV�TOKEN_GT� TOKEN_GTEQ�TOKEN_LBRACE�TOKEN_LBRACKET�TOKEN_LPAREN�TOKEN_LT� TOKEN_LTEQ� TOKEN_MOD� TOKEN_MUL�TOKEN_NE� TOKEN_PIPE� TOKEN_POW�TOKEN_RBRACE�TOKEN_RBRACKET�TOKEN_RPAREN�TOKEN_SEMICOLON� TOKEN_SUB�TOKEN_TILDEr��r��r��r|���r��r��ro���rp���rq���rr���r��r��rk���rl���rm���rs���rt���r����r��rn���ru���r����rv���r8���dictrj���re���r��r����r��� frozensetr/��rP��ry���r���r����r����r�����objectr����r����r����r����r����r����r����r����rV���r\���rZ����<module>r������s������� � � � � ��������������������������������������(��(��(��(��(��(��������������������������������������+��+��+��+��+��+���������������x��|�|����� �6�2�4�(�(� � �R�Z�� (� (� ��B�J�B�B�D� �� � ���R�Z� � &� &� ��2�:� ���M�B�J��������G�G�[�&�)�)�)��0�/�/�/�/�/��K�K�����������b�j�2�3�3�G��K�K�K������ �F�5�M�M� ��v�h�����f�W�o�o���f�W�o�o���F�5�M�M� ��F�5�M�M� ��6�$�<�<���� �#�#���6�$�<�<�� �V�F�^�^� ��v�h������ �#�#���v�h�����6�$�<�<�� �V�F�^�^� ��F�5�M�M� ��F�5�M�M� ��6�$�<�<�� �V�F�^�^� ��F�5�M�M� ��v�h������ �#�#���v�h�����&��%�%���F�5�M�M� ��f�W�o�o���6�,�'�'����f�W�o�o����y�!�!� � �V�F�^�^� ��v�h������ �#�#���F�=�)�)����&��%�%���v�.�/�/����V�N�+�+����&��%�%����y�!�!� ��f�_�-�-����F�=�)�)�����y�!�!� �"�F�#8�9�9��� �&�!4�5�5��� �&�!4�5�5�����0�1�1����F�=�)�)��� �V�F�^�^� ���y�!�!� ��F�5�M�M� � ��� ��� ���� �� �.� � ��� ���� �� �)� ���� ���� ���� ���� ���� ���� ���� �� �(� � � �(�! �"���# �$�� � � � � � � � �5 �� �� � �:��D�B�B�Y�Y�y�-A�-A�B�B�B�C�C��� �s�9�~�~���.�/�/�/�/�/�1D�/�/�/��b�j� �S�X�X�U�U�F�F�9�BS�BS�,T�,T�,T�U�U�U� U� U�U���������������� �� ����)��z�=�2C�D����� "��"��"�&,��,��,�&��&��&�*��*��*�&8��&8��&8�R ?�� ?�� ?�� ?�� ?�f�� ?�� ?�� ?�%J��%J��%J��%J��%J�E��%J��%J��%J�P�����������&���������(��c��c��c��c��c�&��c��c����c�L�����. @�� @�� @�� @�� @�U�� @�� @�� @�E��E��E��E��E�F��E��E��E��E��Es����3 C �� C#�"C#