mkdocs-include-markdown-plugin 7.1.4__tar.gz → 7.1.5__tar.gz

{mkdocs_include_markdown_plugin-7.1.4 → mkdocs_include_markdown_plugin-7.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs-include-markdown-plugin
-Version: 7.1.4
+Version: 7.1.5
 Summary: Mkdocs Markdown includer plugin.
 Project-URL: Source, https://github.com/mondeja/mkdocs-include-markdown-plugin
 Project-URL: Documentation, https://github.com/mondeja/mkdocs-include-markdown-plugin#documentation

{mkdocs_include_markdown_plugin-7.1.4 → mkdocs_include_markdown_plugin-7.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs-include-markdown-plugin"
-version = "7.1.4"
+version = "7.1.5"
 description = "Mkdocs Markdown includer plugin."
 readme = "README.md"
 license = "Apache-2.0"

{mkdocs_include_markdown_plugin-7.1.4 → mkdocs_include_markdown_plugin-7.1.5}/src/mkdocs_include_markdown_plugin/directive.py

@@ -20,10 +20,11 @@ from mkdocs_include_markdown_plugin.logger import logger
 @dataclass
 class DirectiveBoolArgument:  # noqa: D101
     value: bool
-    regex: re.Pattern[str]
+    regex: Callable[[], re.Pattern[str]]
 
 
 if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Iterable
     from typing import Callable, Literal, TypedDict
 
     DirectiveBoolArgumentsDict = dict[str, DirectiveBoolArgument]
@@ -50,18 +51,18 @@ RE_ESCAPED_PUNCTUATION = re.escape(string.punctuation)
 DOUBLE_QUOTED_STR_RE = r'([^"]|(?<=\\)")+'
 SINGLE_QUOTED_STR_RE = r"([^']|(?<=\\)')+"
 
-# In the following regular expression, the substrings "$OPENING_TAG"
-# and "$CLOSING_TAG" will be replaced by the effective opening and
-# closing tags in the `on_config` plugin event.
-INCLUDE_TAG_RE = rf'''
-    (?P<_includer_indent>[ \t\w\\.]*?)$OPENING_TAG
+# In the following regular expression, the substrings "\{%", "%\}"
+# will be replaced by custom opening and closing tags in the `on_config`
+# plugin event if required.
+INCLUDE_TAG_RE = r'''
+    (?P<_includer_indent>[ \t\w\\.]*?)\{%
     \s*
     include
     \s+
-    (?:"(?P<double_quoted_filename>{DOUBLE_QUOTED_STR_RE})")?(?:'(?P<single_quoted_filename>{SINGLE_QUOTED_STR_RE})')?
+    (?:"(?P<double_quoted_filename>''' + DOUBLE_QUOTED_STR_RE + r''')")?(?:'(?P<single_quoted_filename>''' + SINGLE_QUOTED_STR_RE + r''')')?
     (?P<arguments>.*?)
     \s*
-    $CLOSING_TAG
+    %\}
 '''  # noqa: E501
 
 TRUE_FALSE_STR_BOOL = {
@@ -110,6 +111,7 @@ ARGUMENT_REGEXES = {
     'heading-offset': functools.partial(arg, 'heading-offset'),
 }
 
+INCLUDE_MARKDOWN_DIRECTIVE_ARGS = set(ARGUMENT_REGEXES)
 INCLUDE_DIRECTIVE_ARGS = {
     key for key in ARGUMENT_REGEXES if key not in (
         'rewrite-relative-urls', 'heading-offset', 'comments',
@@ -121,29 +123,71 @@ WARN_INVALID_DIRECTIVE_ARGS_REGEX = re.compile(
 )
 
 
+def _maybe_arguments_iter(arguments_string: str) -> Iterable[str]:
+    """Iterate over parts of the string that look like arguments."""
+    current_string_opening = ''  # can be either `'` or `"`
+    inside_string = False
+    escaping = False
+    opening_argument = False  # whether we are at the beginning of an argument
+    current_value = ''
+
+    for c in arguments_string:
+        if inside_string:
+            if c == '\\':
+                escaping = not escaping
+                continue
+            elif c == current_string_opening and not escaping:
+                inside_string = False
+                current_string_opening = ''
+            else:
+                escaping = False
+        elif c == '=':
+            new_current_value = ''
+            for ch in reversed(current_value):
+                if ch in string.whitespace:
+                    current_value = new_current_value[::-1]
+                    break
+                new_current_value += ch
+            yield current_value
+            current_value = ''
+            opening_argument = True
+        elif opening_argument:
+            opening_argument = False
+            if c in ('"', "'"):
+                current_string_opening = c
+                inside_string = True
+                current_value += c
+                current_value += c
+        else:
+            current_value += c
+
+
 def warn_invalid_directive_arguments(
     arguments_string: str,
     directive_lineno: Callable[[], int],
     directive: Literal['include', 'include-markdown'],
     page_src_path: str | None,
     docs_dir: str,
-) -> None:
+) -> list[str]:
     """Warns about the invalid arguments passed to a directive."""
+    used_arguments = []
     valid_args = (
-        INCLUDE_DIRECTIVE_ARGS if directive == 'include'
-        else set(ARGUMENT_REGEXES)
+        INCLUDE_DIRECTIVE_ARGS
+        if directive == 'include'
+        else INCLUDE_MARKDOWN_DIRECTIVE_ARGS
     )
-    for arg_value in WARN_INVALID_DIRECTIVE_ARGS_REGEX.findall(
-        arguments_string,
-    ):
-        if arg_value.split('=', 1)[0] not in valid_args:
+    for maybe_arg in _maybe_arguments_iter(arguments_string):
+        if maybe_arg not in valid_args:
             location = process.file_lineno_message(
                 page_src_path, docs_dir, directive_lineno(),
             )
             logger.warning(
-                f"Invalid argument '{arg_value}' in"
+                f"Invalid argument '{maybe_arg}' in"
                 f" '{directive}' directive at {location}. Ignoring...",
             )
+        else:
+            used_arguments.append(maybe_arg)
+    return used_arguments
 
 
 def parse_filename_argument(
@@ -156,21 +200,23 @@ def parse_filename_argument(
         if raw_filename is None:
             filename = None
         else:
-            filename = raw_filename.replace("\\'", "'")
+            filename = raw_filename.replace(r"\'", "'")
     else:
-        filename = raw_filename.replace('\\"', '"')
+        filename = raw_filename.replace(r'\"', '"')
     return filename, raw_filename
 
 
-def parse_string_argument(match: re.Match[str]) -> str | None:
+def parse_string_argument(match: re.Match[str] | None) -> str | None:
     """Return the string argument matched by ``match``."""
+    if match is None:
+        return None
     value = match[1]
     if value is None:
         value = match[3]
         if value is not None:
-            value = value.replace("\\'", "'")
+            value = value.replace(r"\'", "'")
     else:
-        value = value.replace('\\"', '"')
+        value = value.replace(r'\"', '"')
     return value
 
 
@@ -182,18 +228,31 @@ def create_include_tag(
     Replaces the substrings '$OPENING_TAG' and '$CLOSING_TAG' from
     INCLUDE_TAG_RE by the effective tag.
     """
-    return re.compile(
-        INCLUDE_TAG_RE.replace(' include', f' {tag}', 1).replace(
-            '$OPENING_TAG', re.escape(opening_tag), 1,
-        ).replace('$CLOSING_TAG', re.escape(closing_tag), 1),
-        flags=re.VERBOSE | re.DOTALL,
-    )
+    pattern = INCLUDE_TAG_RE
+    if tag != 'include':
+        pattern = pattern.replace(
+            ' include',
+            (
+                ' include-markdown' if tag == 'include-markdown'
+                else f' {re.escape(tag)}'
+            ),
+            1,
+        )
+
+    if opening_tag != '{%':
+        pattern = pattern.replace(r'\{%', re.escape(opening_tag), 1)
+
+    if closing_tag != '%}':
+        pattern = pattern.replace(r'%\}', re.escape(closing_tag), 1)
+
+    return re.compile(pattern, flags=re.VERBOSE | re.DOTALL)
 
 
 def parse_bool_options(
         option_names: list[str],
         defaults: DefaultValues,
         arguments_string: str,
+        used_arguments: list[str],
 ) -> tuple[DirectiveBoolArgumentsDict, list[str]]:
     """Parse boolean options from arguments string."""
     invalid_args: list[str] = []
@@ -202,16 +261,17 @@ def parse_bool_options(
     for option_name in option_names:
         bool_options[option_name] = DirectiveBoolArgument(
             value=defaults[option_name],  # type: ignore
-            regex=ARGUMENT_REGEXES[option_name](),
+            regex=ARGUMENT_REGEXES[option_name],
         )
 
     for arg_name, arg in bool_options.items():
-        bool_arg_match = arg.regex.search(arguments_string)
-        if bool_arg_match is None:
+        if arg_name not in used_arguments:
             continue
+        bool_arg_match = arg.regex().search(arguments_string)
         try:
             bool_options[arg_name].value = TRUE_FALSE_STR_BOOL[
-                bool_arg_match[1] or TRUE_FALSE_BOOL_STR[arg.value]
+                (bool_arg_match and bool_arg_match[1])
+                or TRUE_FALSE_BOOL_STR[arg.value]
             ]
         except KeyError:
             invalid_args.append(arg_name)

{mkdocs_include_markdown_plugin-7.1.4 → mkdocs_include_markdown_plugin-7.1.5}/src/mkdocs_include_markdown_plugin/event.py

@@ -125,7 +125,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
 
         arguments_string = match['arguments']
 
-        warn_invalid_directive_arguments(
+        used_arguments = warn_invalid_directive_arguments(
             arguments_string,
             directive_lineno,
             'include',
@@ -133,9 +133,11 @@ def get_file_content(  # noqa: PLR0913, PLR0915
             docs_dir,
         )
 
-        exclude_match = ARGUMENT_REGEXES['exclude']().search(arguments_string)
         ignore_paths = [*settings_ignore_paths]
-        if exclude_match is not None:
+        if 'exclude' in used_arguments:
+            exclude_match = ARGUMENT_REGEXES['exclude']().search(
+                arguments_string,
+            )
             exclude_string = parse_string_argument(exclude_match)
             if exclude_string is None:
                 location = process.file_lineno_message(
@@ -169,38 +171,22 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         if files_watcher is not None and not is_url:
             files_watcher.included_files.extend(file_paths_to_include)
 
-        bool_options, invalid_bool_args = parse_bool_options(
-            ['preserve-includer-indent', 'dedent',
-                'trailing-newlines', 'recursive'],
-            defaults,
-            arguments_string,
-        )
-        if invalid_bool_args:
-            location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno(),
-            )
-            raise PluginError(
-                f"Invalid value for '{invalid_bool_args[0]}' argument of"
-                f" 'include' directive at {location}."
-                f' Possible values are true or false.',
-            )
-
-        start_match = ARGUMENT_REGEXES['start']().search(arguments_string)
-        if start_match:
+        start = defaults['start']
+        if 'start' in used_arguments:
+            start_match = ARGUMENT_REGEXES['start']().search(arguments_string)
             start = parse_string_argument(start_match)
             if start is None:
                 location = process.file_lineno_message(
                     page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
-                    "Invalid empty 'start' argument in 'include' directive at"
-                    f' {location}',
+                    "Invalid empty 'start' argument in 'include' directive"
+                    f' at {location}',
                 )
-        else:
-            start = defaults['start']
 
-        end_match = ARGUMENT_REGEXES['end']().search(arguments_string)
-        if end_match:
+        end = defaults['end']
+        if 'end' in used_arguments:
+            end_match = ARGUMENT_REGEXES['end']().search(arguments_string)
             end = parse_string_argument(end_match)
             if end is None:
                 location = process.file_lineno_message(
@@ -210,14 +196,14 @@ def get_file_content(  # noqa: PLR0913, PLR0915
                     "Invalid empty 'end' argument in 'include' directive at"
                     f' {location}',
                 )
-        else:
-            end = defaults['end']
 
-        encoding_match = ARGUMENT_REGEXES['encoding']().search(
-            arguments_string)
-        if encoding_match:
-            encoding = parse_string_argument(encoding_match)
-            if encoding is None:
+        encoding = defaults['encoding']
+        if 'encoding' in used_arguments:
+            encoding_match = ARGUMENT_REGEXES['encoding']().search(
+                arguments_string,
+            )
+            encoding_ = parse_string_argument(encoding_match)
+            if encoding_ is None:
                 location = process.file_lineno_message(
                     page_src_path, docs_dir, directive_lineno(),
                 )
@@ -225,8 +211,28 @@ def get_file_content(  # noqa: PLR0913, PLR0915
                     "Invalid empty 'encoding' argument in 'include'"
                     f' directive at {location}',
                 )
-        else:
-            encoding = defaults['encoding']
+            encoding = encoding_
+
+        bool_options, invalid_bool_args = parse_bool_options(
+            [
+                'preserve-includer-indent',
+                'dedent',
+                'trailing-newlines',
+                'recursive',
+            ],
+            defaults,
+            arguments_string,
+            used_arguments,
+        )
+        if invalid_bool_args:
+            location = process.file_lineno_message(
+                page_src_path, docs_dir, directive_lineno(),
+            )
+            raise PluginError(
+                f"Invalid value for '{invalid_bool_args[0]}' argument of"
+                f" 'include' directive at {location}."
+                f' Possible values are true or false.',
+            )
 
         text_to_include = ''
         expected_but_any_found = [start is not None, end is not None]
@@ -322,7 +328,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         )
 
         includer_indent = match['_includer_indent']
-        empty_includer_indent = ' ' * len(includer_indent)
+        filled_includer_indent = ' ' * len(includer_indent)
 
         filename, raw_filename = parse_filename_argument(match)
         if filename is None:
@@ -336,7 +342,7 @@ def get_file_content(  # noqa: PLR0913, PLR0915
 
         arguments_string = match['arguments']
 
-        warn_invalid_directive_arguments(
+        used_arguments = warn_invalid_directive_arguments(
             arguments_string,
             directive_lineno,
             'include-markdown',
@@ -344,9 +350,11 @@ def get_file_content(  # noqa: PLR0913, PLR0915
             docs_dir,
         )
 
-        exclude_match = ARGUMENT_REGEXES['exclude']().search(arguments_string)
         ignore_paths = [*settings_ignore_paths]
-        if exclude_match is not None:
+        if 'exclude' in used_arguments:
+            exclude_match = ARGUMENT_REGEXES['exclude']().search(
+                arguments_string,
+            )
             exclude_string = parse_string_argument(exclude_match)
             if exclude_string is None:
                 location = process.file_lineno_message(
@@ -379,42 +387,23 @@ def get_file_content(  # noqa: PLR0913, PLR0915
         if files_watcher is not None and not is_url:
             files_watcher.included_files.extend(file_paths_to_include)
 
-        bool_options, invalid_bool_args = parse_bool_options(
-            [
-                'rewrite-relative-urls', 'comments',
-                'preserve-includer-indent', 'dedent',
-                'trailing-newlines', 'recursive',
-            ],
-            defaults,
-            arguments_string,
-        )
-        if invalid_bool_args:
-            location = process.file_lineno_message(
-                page_src_path, docs_dir, directive_lineno(),
-            )
-            raise PluginError(
-                f"Invalid value for '{invalid_bool_args[0]}' argument of"
-                " 'include-markdown' directive at"
-                f' {location}. Possible values are true or false.',
-            )
-
         # start and end arguments
-        start_match = ARGUMENT_REGEXES['start']().search(arguments_string)
-        if start_match:
+        start = defaults['start']
+        if 'start' in used_arguments:
+            start_match = ARGUMENT_REGEXES['start']().search(arguments_string)
             start = parse_string_argument(start_match)
             if start is None:
                 location = process.file_lineno_message(
                     page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
-                    "Invalid empty 'start' argument in 'include-markdown'"
-                    f' directive at {location}',
+                    "Invalid empty 'start' argument in"
+                    f" 'include-markdown' directive at {location}",
                 )
-        else:
-            start = defaults['start']
 
-        end_match = ARGUMENT_REGEXES['end']().search(arguments_string)
-        if end_match:
+        end = defaults['end']
+        if 'end' in used_arguments:
+            end_match = ARGUMENT_REGEXES['end']().search(arguments_string)
             end = parse_string_argument(end_match)
             if end is None:
                 location = process.file_lineno_message(
@@ -424,50 +413,73 @@ def get_file_content(  # noqa: PLR0913, PLR0915
                     "Invalid empty 'end' argument in 'include-markdown'"
                     f' directive at {location}',
                 )
-        else:
-            end = defaults['end']
 
-        encoding_match = ARGUMENT_REGEXES['encoding']().search(
-            arguments_string)
-        if encoding_match:
-            encoding = parse_string_argument(encoding_match)
-            if encoding is None:
+        encoding = defaults['encoding']
+        if 'encoding' in used_arguments:
+            encoding_match = ARGUMENT_REGEXES['encoding']().search(
+                arguments_string,
+            )
+            encoding_ = parse_string_argument(encoding_match)
+            if encoding_ is None:
                 location = process.file_lineno_message(
                     page_src_path, docs_dir, directive_lineno(),
                 )
                 raise PluginError(
-                    "Invalid empty 'encoding' argument in 'include-markdown'"
-                    f' directive at {location}',
+                    "Invalid empty 'encoding' argument in"
+                    f" 'include-markdown' directive at {location}",
                 )
-        else:
-            encoding = defaults['encoding']
+            encoding = encoding_
 
         # heading offset
-        offset_match = ARGUMENT_REGEXES['heading-offset']().search(
+        offset = defaults['heading-offset']
+        if 'heading-offset' in used_arguments:
+            offset_match = ARGUMENT_REGEXES['heading-offset']().search(
+                arguments_string,
+            )
+            if offset_match:
+                offset_raw_value = offset_match[1]
+                if offset_raw_value == '':
+                    location = process.file_lineno_message(
+                        page_src_path, docs_dir, directive_lineno(),
+                    )
+                    raise PluginError(
+                        "Invalid empty 'heading-offset' argument in"
+                        f" 'include-markdown' directive at {location}",
+                    )
+                try:
+                    offset = int(offset_raw_value)
+                except ValueError:
+                    location = process.file_lineno_message(
+                        page_src_path, docs_dir, directive_lineno(),
+                    )
+                    raise PluginError(
+                        f"Invalid 'heading-offset' argument"
+                        f" '{offset_raw_value}' in 'include-markdown'"
+                        f" directive at {location}",
+                    ) from None
+
+        bool_options, invalid_bool_args = parse_bool_options(
+            [
+                'rewrite-relative-urls',
+                'comments',
+                'preserve-includer-indent',
+                'dedent',
+                'trailing-newlines',
+                'recursive',
+            ],
+            defaults,
             arguments_string,
+            used_arguments,
         )
-        if offset_match:
-            offset_raw_value = offset_match[1]
-            if offset_raw_value == '':
-                location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno(),
-                )
-                raise PluginError(
-                    "Invalid empty 'heading-offset' argument in"
-                    f" 'include-markdown' directive at {location}",
-                )
-            try:
-                offset = int(offset_raw_value)
-            except ValueError:
-                location = process.file_lineno_message(
-                    page_src_path, docs_dir, directive_lineno(),
-                )
-                raise PluginError(
-                    f"Invalid 'heading-offset' argument \"{offset_raw_value}\""
-                    f" in 'include-markdown' directive at {location}",
-                ) from None
-        else:
-            offset = defaults['heading-offset']
+        if invalid_bool_args:
+            location = process.file_lineno_message(
+                page_src_path, docs_dir, directive_lineno(),
+            )
+            raise PluginError(
+                f"Invalid value for '{invalid_bool_args[0]}' argument of"
+                " 'include-markdown' directive at"
+                f' {location}. Possible values are true or false.',
+            )
 
         separator = '\n' if bool_options['trailing-newlines'].value else ''
         if not start and not end:
@@ -555,14 +567,15 @@ def get_file_content(  # noqa: PLR0913, PLR0915
                 new_text_to_include = textwrap.dedent(new_text_to_include)
 
             # includer indentation preservation
-            if bool_options['preserve-includer-indent'].value:
-                new_text_to_include = ''.join(
-                    (empty_includer_indent if i > 0 else '') + line
-                    for i, line in enumerate(
-                        new_text_to_include.splitlines(keepends=True)
-                        or [''],
+            if bool_options['preserve-includer-indent'].value and (
+                new_text_to_include
+            ):
+                lines = new_text_to_include.splitlines(keepends=True)
+                new_text_to_include = lines[0]
+                for i in range(1, len(lines)):
+                    new_text_to_include += (
+                        filled_includer_indent + lines[i]
                     )
-                )
 
             if offset:
                 new_text_to_include = process.increase_headings_offset(

{mkdocs_include_markdown_plugin-7.1.4 → mkdocs_include_markdown_plugin-7.1.5}/src/mkdocs_include_markdown_plugin/process.py

@@ -249,9 +249,10 @@ def transform_line_by_line_skipping_codeblocks(
         markdown: str,
         func: Callable[[str], str],
 ) -> str:
-    """Apply a transformation line by line in a Markdown text using a function.
+    """Apply a transformation line by line in a Markdown text using a function,.
 
-    Skip fenced codeblock lines, where the transformation never is applied.
+    Skip fenced codeblock lines and empty lines, where the transformation
+    is never applied.
 
     Indented codeblocks are not taken into account because in the practice
     this function is only used for transformations of heading prefixes. See
@@ -263,13 +264,15 @@ def transform_line_by_line_skipping_codeblocks(
 
     lines = []
     for line in io.StringIO(markdown):
+        lstripped_line = line.lstrip()
         if not _current_fcodeblock_delimiter:
-            lstripped_line = line.lstrip()
-            if lstripped_line.startswith(('```', '~~~')):
-                _current_fcodeblock_delimiter = lstripped_line[:3]
+            if lstripped_line.startswith('```'):
+                _current_fcodeblock_delimiter = '```'
+            elif lstripped_line.startswith('~~~'):
+                _current_fcodeblock_delimiter = '~~~'
             else:
                 line = func(line)  # noqa: PLW2901
-        elif line.lstrip().startswith(_current_fcodeblock_delimiter):
+        elif lstripped_line.startswith(_current_fcodeblock_delimiter):
             _current_fcodeblock_delimiter = ''
         lines.append(line)
 
@@ -287,20 +290,12 @@ def rewrite_relative_urls(
     ``source_path`` will still work when inserted into a file at
     ``destination_path``.
     """
-    from urllib.parse import urlparse, urlunparse
-
     def rewrite_url(url: str) -> str:
-        if is_url(url):
-            return url
-
-        scheme, netloc, path, params, query, fragment = urlparse(url)
-
-        # absolute or mail
-        if path.startswith('/') or scheme == 'mailto':
+        if is_url(url) or is_absolute_path(url):
             return url
 
         new_path = os.path.relpath(
-            os.path.join(os.path.dirname(source_path), path),
+            os.path.join(os.path.dirname(source_path), url),
             os.path.dirname(destination_path),
         )
 
@@ -308,18 +303,14 @@ def rewrite_relative_urls(
         new_path = new_path.replace('\\', '/').replace('//', '/')
 
         try:
-            if path[-1] == '/':
+            if url[-1] == '/':
                 # the above operation removes a trailing slash,
                 # so add it back if it was present in the input
                 new_path += '/'
         except IndexError:  # pragma: no cover
             pass
 
-        # ensure that links to the same file are not rewritten
-        if new_path == '.':
-            new_path = ''
-
-        return urlunparse((scheme, netloc, new_path, params, query, fragment))
+        return new_path
 
     def found_href(m: re.Match[str], url_group_index: int = -1) -> str:
         match_start, match_end = m.span(0)
@@ -528,27 +519,68 @@ def filter_paths(
     return response
 
 
+def _is_valid_url_scheme_char(c: str) -> bool:
+    """Determine is a character is a valid URL scheme character.
+
+    Valid characters are:
+
+    ```
+    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+-.
+    ```
+    """
+    codepoint = ord(c)
+    A = 65
+    Z = 90
+    a = 97
+    z = 122
+    zero = 48
+    nine = 57
+    dot = 46
+    plus = 43
+    minus = 45
+    return (
+        A <= codepoint <= Z
+        or a <= codepoint <= z
+        or zero <= codepoint <= nine
+        or codepoint in (plus, minus, dot)
+    )
+
+
 def is_url(string: str) -> bool:
-    """Determine if a string is an URL."""
-    if ':' not in string:  # fast path
+    """Determine if a string is an URL.
+
+    The implementation has been adapted from `urllib.urlparse`.
+    """
+    i = string.find(':')
+    if i <= 1:  # noqa: PLR2004 -> exclude C: or D: on Windows
         return False
-    from urllib.parse import urlparse
 
     try:
-        result = urlparse(string)
-        return all([result.scheme, result.netloc])
-    except ValueError:  # pragma: no cover
+        return all(_is_valid_url_scheme_char(string[j]) for j in range(i))
+    except (IndexError, ValueError):  # pragma: no cover
         return False
 
 
 def is_relative_path(string: str) -> bool:
     """Check if a string looks like a relative path."""
-    return string.startswith(('./', '../'))
+    try:
+        return (
+            string[0] == '.'
+            and (
+                string[1] == '/'
+                or (string[1] == '.' and string[2] == '/')
+            )
+        )
+    except IndexError:  # pragma: no cover
+        return False
 
 
 def is_absolute_path(string: str) -> bool:
     """Check if a string looks like an absolute path."""
-    return string.startswith((os.sep, '/'))
+    try:
+        return string[0] == '/' or string[0] == os.sep
+    except IndexError:  # pragma: no cover
+        return False
 
 
 def read_file(file_path: str, encoding: str) -> str:
@@ -581,14 +613,12 @@ def read_url(
 def safe_os_path_relpath(path: str, start: str) -> str:
     """Return the relative path of a file from a start directory.
 
-    Safe version of `os.path.relpath` that catches `ValueError` exceptions
-    on Windows and returns the original path in case of error.
+    Safe version of `os.path.relpath` that catches possible `ValueError`
+    exceptions and returns the original path in case of error.
     On Windows, `ValueError` is raised when `path` and `start` are on
     different drives.
     """
-    if os.name != 'nt':  # pragma: nt no cover
-        return os.path.relpath(path, start)
-    try:  # pragma: nt cover
+    try:
         return os.path.relpath(path, start)
     except ValueError:  # pragma: no cover
         return path