Edit File: _native.cpython-311.pyc
� ������Fh�����������������������������d�dl�ZddlmZ�dej��������defd�Zdej��������ej�����������������defd�Zdej��������defd�Z dej��������defd �Z dS�) �����N����)�Markup�s�returnc������������������d����t����������|�d������������r!t����������|������������������������������������������������S�t����������t����������|����������������������������������dd���������������������������������dd���������������������������������dd���������������������������������dd ���������������������������������d d������������������������S�)a���Replace the characters ``&``, ``<``, ``>``, ``'``, and ``"`` in the string with HTML-safe sequences. Use this if you need to display text that might contain such characters in HTML. If the object has an ``__html__`` method, it is called and the return value is assumed to already be safe for HTML. :param s: An object to be converted to a string and escaped. :return: A :class:`Markup` string with the escaped text. �__html__�&z&�>z>�<z<�'z'�"z")�hasattrr���r����str�replace�r���s��� �t/builddir/build/BUILD/imunify360-venv-2.5.3/opt/imunify360/venv/lib64/python3.11/site-packages/markupsafe/_native.py�escaper������s���������q�*����$��a�j�j�l�l�#�#�#���A��� ���g� � � ���f� � � ���f� � � ���g� � � ���g� � � ���������c������������������@�����|��t������������������������S�t����������|�������������S�)a��Like :func:`escape` but treats ``None`` as the empty string. Useful with optional values, as otherwise you get the string ``'None'`` when the value is ``None``. >>> escape(None) Markup('None') >>> escape_silent(None) Markup('') )r���r���r���s��� r���� escape_silentr������s������� �y��x�x���!�9�9�r���c������������������N�����t����������|�t����������������������st����������|�������������S�|�S�)a���Convert an object to a string if it isn't already. This preserves a :class:`Markup` string rather than converting it back to a basic string, so it will still be marked as safe and won't be escaped again. >>> value = escape("<User 1>") >>> value Markup('<User 1>') >>> escape(str(value)) Markup('&lt;User 1&gt;') >>> escape(soft_str(value)) Markup('<User 1>') )� isinstancer���r���s��� r����soft_strr���.���s&��������a�������1�v�v� ��Hr���c������������������b�����dd�l�}|���������������������dt����������d��������������t����������|�������������S�)Nr���z^'soft_unicode' has been renamed to 'soft_str'. The old name will be removed in MarkupSafe 2.1.����)� stacklevel)�warnings�warn�DeprecationWarningr���)r���r���s��� r����soft_unicoder ���B���s?�������O�O�O��M�M� .��� ����������A�;�;�r���)�typing�t��r����Anyr����Optionalr���r���r���r �����r���r����<module>r'������s���������������������������a�e������������0 �Q�Z���&�� �6�� �� �� �� � ���� �#�� �� �� �� �( �A�E�� �c�� �� �� �� �� �� r���