pyscript-programming-language 1.7.1__tar.gz → 1.7.3__tar.gz

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pyscript-programming-language
-Version: 1.7.1
+Version: 1.7.3
 Summary: PyScript Programming Language
-Home-page: https://github.com/azzammuhyala/pyscript
+Home-page: https://azzammuhyala.github.io/pyscript
 Author: azzammuhyala
 Author-email: azzammuhyala@gmail.com
 License: MIT

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/__init__.pyi

@@ -1,5 +1,3 @@
-from .core.highlight import PygmentsPyScriptLexer as PygmentsPyScriptLexer
-
 from typing import TYPE_CHECKING, Any, Callable, Iterator, Literal, Optional
 
 if TYPE_CHECKING:
@@ -15,6 +13,7 @@ if TYPE_CHECKING:
     from types import ModuleType
 
 from . import core as core
+from .core.highlight import PygmentsPyScriptLexer as PygmentsPyScriptLexer
 
 DEFAULT: int
 DEBUG: int
@@ -37,13 +36,8 @@ def pys_highlight(
         Callable[
             [
                 str | Literal[
-                    'start',
-                    'invalid',
-                    'identifier', 'identifier-constant', 'identifier-function', 'identifier-type',
-                    'keyword', 'keyword-constant',
-                    'number', 'string', 'comment', 'newline',
-                    'default',
-                    'end'
+                    'start', 'invalid', 'identifier', 'identifier-constant', 'identifier-function', 'identifier-type',
+                    'keyword', 'keyword-constant', 'number', 'string', 'comment', 'newline', 'default', 'end'
                 ],
                 PysPosition,
                 str

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/__main__.py

@@ -9,7 +9,8 @@ from .core.version import __version__
 
 from argparse import ArgumentParser
 from os import environ
-from sys import executable, stderr, version_info, exit, setrecursionlimit
+
+import sys
 
 FORMAT_HIGHLIGHT_MAP = {
     'html': HLFMT_HTML,
@@ -18,8 +19,8 @@ FORMAT_HIGHLIGHT_MAP = {
 }
 
 parser = ArgumentParser(
-    prog=f'{get_module_name_from_path(executable)} -m pyscript',
-    description=f'PyScript Launcher for Python Version {".".join(map(str, version_info))}'
+    prog=f'{get_module_name_from_path(sys.executable)} -m pyscript',
+    description=f'PyScript Launcher for Python Version {".".join(map(str, sys.version_info))}'
 )
 
 parser.add_argument(
@@ -27,7 +28,7 @@ parser.add_argument(
     type=str,
     nargs='?',
     default=None,
-    help="file path"
+    help="File path to be executed"
 )
 
 parser.add_argument(
@@ -40,53 +41,53 @@ parser.add_argument(
     '-c', '--command',
     type=str,
     default=None,
-    help="execute PyScript from argument",
+    help="Execute program from a string argument",
 )
 
 parser.add_argument(
     '-d', '--debug',
     action='store_true',
-    help="set a debug flag, this will remove the assert statement"
+    help="Set a debug flag, this will remove the assert statement"
 )
 
 parser.add_argument(
     '-i', '--inspect',
     action='store_true',
-    help="inspect interactively after running a file",
+    help="Inspect interactively after running a 'file'",
 )
 
 parser.add_argument(
     '-l', '--highlight',
     choices=tuple(FORMAT_HIGHLIGHT_MAP.keys()),
     default=None,
-    help='generate PyScript highlight code from a file'
+    help="Generate highlight code from a 'file'"
 )
 
 parser.add_argument(
     '-n', '--no-color',
     action='store_true',
-    help="no colorful traceback"
+    help="Suppress colored output"
 )
 
 parser.add_argument(
     '-r', '--py-recursion',
     type=int,
     default=None,
-    help="set a python recursion limit"
+    help="Set a Python recursion limit"
 )
 
 def argument_error(argument, message):
-    parser.print_usage(stderr)
+    parser.print_usage(sys.stderr)
     parser.exit(2, f"{parser.prog}: error: argument {argument}: {message}\n")
 
 args = parser.parse_args()
 
 if args.highlight and args.file is None:
-    argument_error("-l/--highlight", "file path require")
+    argument_error("-l/--highlight", "argument 'file' required")
 
 if args.py_recursion is not None:
     try:
-        setrecursionlimit(args.py_recursion)
+        sys.setrecursionlimit(args.py_recursion)
     except BaseException as e:
         argument_error("-r/--py-recursion", e)
 
@@ -121,7 +122,7 @@ if args.file is not None:
 
     if args.highlight:
         try:
-            print(pys_highlight(file, FORMAT_HIGHLIGHT_MAP.get(args.highlight, None)))
+            print(pys_highlight(file, FORMAT_HIGHLIGHT_MAP.get(args.highlight)))
         except BaseException as e:
             parser.error(f"file {path!r}: Highlight error: {e}")
 
@@ -150,4 +151,4 @@ elif args.command is not None:
 else:
     code = pys_shell(undefined, flags)
 
-exit(code)
+sys.exit(code)

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/core/analyzer.py

@@ -157,23 +157,25 @@ class PysAnalyzer(Pys):
         self.visit(node.right)
 
     def visit_UnaryOperatorNode(self, node):
+        value = node.value
+
         if is_incremental(node.operand.type):
-            type = node.value.__class__
+            type = value.__class__
             operator = 'increase' if node.operand.type == TOKENS['DOUBLE-PLUS'] else 'decrease'
 
             if type is PysKeywordNode:
-                self.throw(f"cannot {operator} {node.value.token.value}", node.value.position)
+                self.throw(f"cannot {operator} {value.name.value}", value.position)
                 return
 
-            elif isinstance(node.value, PysNode):
+            elif isinstance(value, PysNode):
                 if type not in (PysIdentifierNode, PysAttributeNode, PysSubscriptNode):
-                    self.throw(f"cannot {operator} literal", node.value.position)
+                    self.throw(f"cannot {operator} literal", value.position)
                     return
 
             else:
                 raise TypeError("UnaryOperator: node.value is not PysNode")
 
-        self.visit(node.value)
+        self.visit(value)
 
     def visit_StatementsNode(self, node):
         for element in node.body:
@@ -435,7 +437,7 @@ class PysAnalyzer(Pys):
                     return
 
             elif type is PysKeywordNode:
-                self.throw(f"cannot delete {target.token.value}", target.position)
+                self.throw(f"cannot delete {target.name.value}", target.position)
                 return
 
             elif isinstance(target, PysNode):
@@ -502,7 +504,7 @@ class PysAnalyzer(Pys):
                     return
 
         elif type is PysKeywordNode:
-            self.throw(f"cannot assign to {node.token.value}", node.position)
+            self.throw(f"cannot assign to {node.name.value}", node.position)
 
         elif isinstance(node, PysNode):
             if type is not PysIdentifierNode:

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/core/cache.py

@@ -71,7 +71,7 @@ class PysHook(Pys):
     @display.setter
     def display(self, value):
         if value is not None and not callable(value):
-            raise TypeError("sys.hook.display: must be callable")
+            raise TypeError("hook.display: must be callable")
         singletons['hook.display'] = value
 
     @property
@@ -81,7 +81,7 @@ class PysHook(Pys):
     @exception.setter
     def exception(self, value):
         if value is not None and not callable(value):
-            raise TypeError("sys.hook.exception: must be callable")
+            raise TypeError("hook.exception: must be callable")
         singletons['hook.exception'] = value
 
     @property
@@ -91,7 +91,7 @@ class PysHook(Pys):
     @ps1.setter
     def ps1(self, value):
         if not isinstance(value, str):
-            raise TypeError("sys.hook.ps1: must be a string")
+            raise TypeError("hook.ps1: must be a string")
         singletons['hook.ps1'] = value
 
     @property
@@ -101,7 +101,7 @@ class PysHook(Pys):
     @ps2.setter
     def ps2(self, value):
         if not isinstance(value, str):
-            raise TypeError("sys.hook.ps2: must be a string")
+            raise TypeError("hook.ps2: must be a string")
         singletons['hook.ps2'] = value
 
 PysUndefined()

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/core/exceptions.py

@@ -21,13 +21,15 @@ class PysTraceback(Pys):
         return f'<traceback of exception {self.exception!r}>'
 
     def string_traceback(self):
+        from .position import format_arrow  # circular import problem solved
+
         context = self.context
         position = self.position
 
         if colored := not (context.flags & NO_COLOR):
             reset = acolor('reset')
             magenta = acolor('magenta')
-            bmagenta = acolor('magenta', BOLD)
+            bmagenta = acolor('magenta', style=BOLD)
         else:
             reset = ''
             magenta = ''
@@ -44,7 +46,7 @@ class PysTraceback(Pys):
                 '{}{}{}'.format(
                     '' if is_positionless else f', line {magenta}{position.start_line}{reset}',
                     '' if context_name is None else f', in {magenta}{context_name}{reset}',
-                    '' if is_positionless else f'\n{indent(position.format_arrow(colored), 4)}'
+                    '' if is_positionless else f'\n{indent(format_arrow(position, colored), 4)}'
                 )
             )
 

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/core/highlight.py

@@ -3,15 +3,33 @@ from .buffer import PysFileBuffer
 from .checks import is_left_bracket, is_right_bracket, is_bracket, is_constant_keywords, is_public_attribute
 from .constants import TOKENS, KEYWORDS, CONSTANT_KEYWORDS, HIGHLIGHT
 from .lexer import PysLexer
-from .mapping import BRACKETS_MAP, HIGHLIGHT_MAP
+from .mapping import BRACKETS_MAP
 from .position import PysPosition
 from .pysbuiltins import pys_builtins
 from .utils.ansi import acolor
 from .utils.decorators import typechecked
 
 from html import escape as html_escape
+from types import MappingProxyType
 from typing import Callable, Optional
 
+HIGHLIGHT_MAP = MappingProxyType({
+    'default': '#D4D4D4',
+    'keyword': '#C586C0',
+    'keyword-constant': '#307CD6',
+    'identifier': '#8CDCFE',
+    'identifier-constant': '#2EA3FF',
+    'identifier-function': '#DCDCAA',
+    'identifier-type': '#4EC9B0',
+    'number': '#B5CEA8',
+    'string': '#CE9178',
+    'brackets-0': '#FFD705',
+    'brackets-1': '#D45DBA',
+    'brackets-2': '#1A9FFF',
+    'comment': '#549952',
+    'invalid': '#B51819'
+})
+
 _builtin_types = tuple(
     name
     for name, object in pys_builtins.__dict__.items()
@@ -221,7 +239,7 @@ except ImportError:
     class PygmentsPyScriptLexer(Pys):
 
         def __new__(cls, *args, **kwargs):
-            raise ModuleNotFoundError("pygments is not found")
+            raise ModuleNotFoundError("module pygments is not found")
 
 @typechecked
 class _PysHighlightFormatter(Pys):

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/core/lexer.py

@@ -9,8 +9,23 @@ from .token import PysToken
 from .utils.decorators import typechecked
 
 from unicodedata import lookup as unicode_lookup
+from types import MappingProxyType
 from typing import Optional
-from sys import stderr
+
+import sys
+
+ESCAPE_CHARACTERS_MAP = MappingProxyType({
+    '\\': '\\',
+    "'": "'",
+    '"': '"',
+    'n': '\n',
+    'r': '\r',
+    't': '\t',
+    'b': '\b',
+    'f': '\f',
+    'a': '\a',
+    'v': '\v'
+})
 
 class PysLexer(Pys):
 
@@ -415,24 +430,8 @@ class PysLexer(Pys):
                         self.advance()
 
                 elif self.character_in('\\\'"nrtbfav\n'):
-
-                    if self.character_in('\\\'"'):
-                        string += self.current_character
-                    elif self.current_character == 'n':
-                        string += '\n'
-                    elif self.current_character == 'r':
-                        string += '\r'
-                    elif self.current_character == 't':
-                        string += '\t'
-                    elif self.current_character == 'b':
-                        string += '\b'
-                    elif self.current_character == 'f':
-                        string += '\f'
-                    elif self.current_character == 'a':
-                        string += '\a'
-                    elif self.current_character == 'v':
-                        string += '\v'
-
+                    if escape_character := ESCAPE_CHARACTERS_MAP.get(self.current_character):
+                        string += escape_character
                     self.advance()
 
                 elif decoded_error_message is None:
@@ -521,7 +520,7 @@ class PysLexer(Pys):
                             warning_displayed = True
                             print(
                                 f"SyntaxWarning: invalid escape sequence '\\{self.current_character}'",
-                                file=stderr
+                                file=sys.stderr
                             )
 
                         string += '\\' + self.current_character

pyscript_programming_language-1.7.3/pyscript/core/mapping.py

@@ -0,0 +1,131 @@
+from .constants import TOKENS, KEYWORDS
+
+from operator import (
+    is_not, eq, ne, lt, gt, le, ge, add, sub, mul, truediv, floordiv, pow, matmul, mod, and_, or_, xor, lshift, rshift,
+    iadd, isub, imul, itruediv, ifloordiv, ipow, imatmul, imod, iand, ior, ixor, ilshift, irshift, pos, neg, inv
+)
+from types import MappingProxyType
+
+BINARY_FUNCTIONS_MAP = MappingProxyType({
+    TOKENS['NOT-IN']: lambda a, b : a not in b,
+    TOKENS['IS-NOT']: is_not,
+    TOKENS['PLUS']: add,
+    TOKENS['MINUS']: sub,
+    TOKENS['STAR']: mul,
+    TOKENS['SLASH']: truediv,
+    TOKENS['DOUBLE-SLASH']: floordiv,
+    TOKENS['DOUBLE-STAR']: pow,
+    TOKENS['AT']: matmul,
+    TOKENS['PERCENT']: mod,
+    TOKENS['AMPERSAND']: and_,
+    TOKENS['PIPE']: or_,
+    TOKENS['CIRCUMFLEX']: xor,
+    TOKENS['DOUBLE-LESS-THAN']: lshift,
+    TOKENS['DOUBLE-GREATER-THAN']: rshift,
+    TOKENS['DOUBLE-EQUAL']: eq,
+    TOKENS['EQUAL-EXCLAMATION']: ne,
+    TOKENS['LESS-THAN']: lt,
+    TOKENS['GREATER-THAN']: gt,
+    TOKENS['EQUAL-LESS-THAN']: le,
+    TOKENS['EQUAL-GREATER-THAN']: ge,
+    TOKENS['EQUAL-PLUS']: iadd,
+    TOKENS['EQUAL-MINUS']: isub,
+    TOKENS['EQUAL-STAR']: imul,
+    TOKENS['EQUAL-SLASH']: itruediv,
+    TOKENS['EQUAL-DOUBLE-SLASH']: ifloordiv,
+    TOKENS['EQUAL-DOUBLE-STAR']: ipow,
+    TOKENS['EQUAL-AT']: imatmul,
+    TOKENS['EQUAL-PERCENT']: imod,
+    TOKENS['EQUAL-AMPERSAND']: iand,
+    TOKENS['EQUAL-PIPE']: ior,
+    TOKENS['EQUAL-CIRCUMFLEX']: ixor,
+    TOKENS['EQUAL-DOUBLE-LESS-THAN']: ilshift,
+    TOKENS['EQUAL-DOUBLE-GREATER-THAN']: irshift,
+})
+
+UNARY_FUNCTIONS_MAP = MappingProxyType({
+    TOKENS['PLUS']: pos,
+    TOKENS['MINUS']: neg,
+    TOKENS['TILDE']: inv
+})
+
+KEYWORDS_TO_VALUES_MAP = MappingProxyType({
+    KEYWORDS['True']: True,
+    KEYWORDS['False']: False,
+    KEYWORDS['None']: None,
+    KEYWORDS['true']: True,
+    KEYWORDS['false']: False,
+    KEYWORDS['none']: None
+})
+
+BRACKETS_MAP = MappingProxyType({
+    TOKENS['LEFT-PARENTHESIS']: TOKENS['RIGHT-PARENTHESIS'],
+    TOKENS['LEFT-SQUARE']: TOKENS['RIGHT-SQUARE'],
+    TOKENS['LEFT-CURLY']: TOKENS['RIGHT-CURLY']
+})
+
+SYMBOLS_TOKEN_MAP = MappingProxyType({
+    TOKENS['NOT-IN']: KEYWORDS['not'] + ' ' + KEYWORDS['in'],
+    TOKENS['IS-NOT']: KEYWORDS['is'] + ' ' + KEYWORDS['not'],
+    TOKENS['NULL']: '\0',
+    TOKENS['NEWLINE']: '\n',
+    TOKENS['EXCLAMATION']: '!',
+    TOKENS['COMMENT']: '#',
+    TOKENS['PERCENT']: '%',
+    TOKENS['AMPERSAND']: '&',
+    TOKENS['RIGHT-PARENTHESIS']: ')',
+    TOKENS['LEFT-PARENTHESIS']: '(',
+    TOKENS['STAR']: '*',
+    TOKENS['PLUS']: '+',
+    TOKENS['COMMA']: ',',
+    TOKENS['MINUS']: '-',
+    TOKENS['DOT']: '.',
+    TOKENS['SLASH']: '/',
+    TOKENS['COLON']: ':',
+    TOKENS['SEMICOLON']: ';',
+    TOKENS['LESS-THAN']: '<',
+    TOKENS['EQUAL']: '=',
+    TOKENS['GREATER-THAN']: '>',
+    TOKENS['QUESTION']: '?',
+    TOKENS['AT']: '@',
+    TOKENS['LEFT-SQUARE']: '[',
+    TOKENS['RIGHT-SQUARE']: ']',
+    TOKENS['CIRCUMFLEX']: '^',
+    TOKENS['LEFT-CURLY']: '{',
+    TOKENS['PIPE']: '|',
+    TOKENS['RIGHT-CURLY']: '}',
+    TOKENS['TILDE']: '~',
+    TOKENS['DOUBLE-AMPERSAND']: '&&',
+    TOKENS['DOUBLE-STAR']: '**',
+    TOKENS['DOUBLE-PLUS']: '++',
+    TOKENS['DOUBLE-MINUS']: '--',
+    TOKENS['DOUBLE-SLASH']: '//',
+    TOKENS['DOUBLE-LESS-THAN']: '<<',
+    TOKENS['DOUBLE-EQUAL']: '==',
+    TOKENS['DOUBLE-GREATER-THAN']: '>>',
+    TOKENS['DOUBLE-QUESTION']: '??',
+    TOKENS['DOUBLE-PIPE']: '||',
+    TOKENS['TRIPLE-DOT']: '...',
+    TOKENS['EQUAL-EXCLAMATION']: '!=',
+    TOKENS['EQUAL-PERCENT']: '%=',
+    TOKENS['EQUAL-AMPERSAND']: '&=',
+    TOKENS['EQUAL-STAR']: '*=',
+    TOKENS['EQUAL-PLUS']: '+=',
+    TOKENS['EQUAL-MINUS']: '-=',
+    TOKENS['EQUAL-SLASH']: '/=',
+    TOKENS['EQUAL-COLON']: ':=',
+    TOKENS['EQUAL-LESS-THAN']: '<=',
+    TOKENS['EQUAL-GREATER-THAN']: '>=',
+    TOKENS['EQUAL-AT']: '@=',
+    TOKENS['EQUAL-CIRCUMFLEX']: '^=',
+    TOKENS['EQUAL-PIPE']: '|=',
+    TOKENS['EQUAL-TILDE']: '~=',
+    TOKENS['EQUAL-DOUBLE-STAR']: '**=',
+    TOKENS['EQUAL-DOUBLE-SLASH']: '//=',
+    TOKENS['EQUAL-DOUBLE-LESS-THAN']: '<<=',
+    TOKENS['EQUAL-DOUBLE-GREATER-THAN']: '>>=',
+    TOKENS['EQUAL-ARROW']: '=>',
+    TOKENS['EXCLAMATION-TILDE']: '~!'
+})
+
+EMPTY_MAP = MappingProxyType({})

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/core/objects.py

@@ -19,10 +19,11 @@ class PysCode(PysObject):
 class PysPythonFunction(PysObject):
 
     def __init__(self, func):
-        from .handlers import handle_call
+        from .handlers import handle_call  # circular import problem solved
 
-        self.__name__ = func.__name__
-        self.__qualname__ = func.__qualname__
+        self.__name__ = getattr(func, '__name__', '<function>')
+        self.__qualname__ = getattr(func, '__qualname__', '<function>')
+        self.__doc__ = getattr(func, '__doc__', None)
         self.__func__ = func
         self.__code__ = PysCode(
             position=None,
@@ -46,7 +47,7 @@ class PysPythonFunction(PysObject):
 class PysFunction(PysObject):
 
     def __init__(self, name, qualname, parameters, body, position, context):
-        from .interpreter import visit
+        from .interpreter import visit  # circular import problem solved
 
         context = context.parent if isinstance(context, PysClassContext) else context
 

{pyscript_programming_language-1.7.1 → pyscript_programming_language-1.7.3}/pyscript/core/parser.py

@@ -3,7 +3,7 @@ from .checks import is_right_bracket
 from .constants import TOKENS, KEYWORDS, DEFAULT, REVERSE_POW_XOR
 from .context import PysContext
 from .exceptions import PysTraceback
-from .mapping import BRACKETS_ITERABLE_MAP, NODE_ITERABLE_MAP, BRACKETS_MAP
+from .mapping import BRACKETS_MAP
 from .nodes import *
 from .position import PysPosition
 from .results import PysParserResult
@@ -11,8 +11,23 @@ from .token import PysToken
 from .utils.decorators import typechecked
 from .utils.generic import setimuattr
 
+from types import MappingProxyType
 from typing import Optional, Callable
 
+BRACKETS_ITERABLE_MAP = MappingProxyType({
+    'dict': TOKENS['LEFT-CURLY'],
+    'set': TOKENS['LEFT-CURLY'],
+    'list': TOKENS['LEFT-SQUARE'],
+    'tuple': TOKENS['LEFT-PARENTHESIS']
+})
+
+NODE_ITERABLE_MAP = MappingProxyType({
+    'dict': PysDictionaryNode,
+    'set': PysSetNode,
+    'list': PysListNode,
+    'tuple': PysTupleNode
+})
+
 class PysParser(Pys):
 
     @typechecked

pyscript_programming_language-1.7.3/pyscript/core/position.py

@@ -0,0 +1,99 @@
+from .bases import Pys
+from .buffer import PysFileBuffer
+from .utils.ansi import BOLD, acolor
+from .utils.decorators import typechecked, immutable
+from .utils.generic import setimuattr
+
+@immutable
+class PysPosition(Pys):
+
+    __slots__ = ('file', 'start', 'end', 'start_line', 'start_column', 'end_line', 'end_column', 'is_positionless')
+
+    @typechecked
+    def __init__(self, file: PysFileBuffer, start: int, end: int) -> None:
+        is_positionless = start < 0 or end < 0 or start > end or end > len(file.text) + 1
+
+        setimuattr(self, 'file', file)
+        setimuattr(self, 'start', -1 if is_positionless else start)
+        setimuattr(self, 'end', -1 if is_positionless else end)
+        setimuattr(self, 'start_line', -1 if is_positionless else file.text.count('\n', 0, start) + 1)
+        setimuattr(self, 'start_column', -1 if is_positionless else start - file.text.rfind('\n', 0, start))
+        setimuattr(self, 'end_line', -1 if is_positionless else file.text.count('\n', 0, end) + 1)
+        setimuattr(self, 'end_column', -1 if is_positionless else end - file.text.rfind('\n', 0, end))
+        setimuattr(self, 'is_positionless', is_positionless)
+
+    def __repr__(self):
+        return f'<Position({self.start!r}, {self.end!r}) from {self.file.name!r}>'
+
+def format_arrow(position, colored=True):
+    if position.is_positionless:
+        return ''
+
+    if colored:
+        reset = acolor('reset')
+        bred = acolor('red', style=BOLD)
+    else:
+        reset = ''
+        bred = ''
+
+    line_start = position.start_line
+    line_end = position.end_line
+    column_start = position.start_column
+    column_end = position.end_column
+
+    text = position.file.text
+
+    start = text.rfind('\n', 0, position.start) + 1
+    end = text.find('\n', start + 1)
+    if end == -1:
+        end = len(text)
+
+    if text[position.start:position.end] in ('', '\n'):
+        if position.start > start:
+            line = text[start:end].lstrip().replace('\t', ' ')
+            return f'{line}\n{bred}{" " * len(line)}^{reset}'
+        return f'\n{bred}^{reset}'
+
+    result = []
+    lines = []
+    count = line_end - line_start + 1
+
+    for i in range(count):
+        line = text[start:end].lstrip('\n')
+
+        lines.append(
+            (
+                line,
+                len(line.lstrip()),
+                column_start - 1 if i == 0 else 0,
+                column_end - 1 if i == count - 1 else len(line)
+            )
+        )
+
+        start = end
+        end = text.find('\n', start + 1)
+        if end == -1:
+            end = len(text)
+
+    minimum_indent = min(len(line) - line_code_length for line, line_code_length, _, _ in lines)
+
+    for i, (line, line_code_length, start, end) in enumerate(lines):
+        line = line[minimum_indent:]
+        er = end - minimum_indent
+
+        if i == 0:
+            sr = start - minimum_indent
+
+            arrow = '^' * (end - start)
+            line = f'{line[:sr]}{bred}{line[sr:er]}{reset}{line[er:]}\n{" " * sr}{bred}{arrow}{reset}'
+
+        else:
+            indent = len(line) - line_code_length
+
+            arrow = '^' * (end - start - (minimum_indent + indent))
+            line = f'{line[:indent]}{bred}{line[indent:er]}{reset}{line[er:]}\n{" " * indent}{bred}{arrow}{reset}'
+
+        if arrow:
+            result.append(line)
+
+    return '\n'.join(result).replace('\t', ' ')