omdev 0.0.0.dev36__py3-none-any.whl → 0.0.0.dev37__py3-none-any.whl

omdev/scripts/pyproject.py

@@ -77,12 +77,7 @@ if sys.version_info < (3, 8):
 ########################################
 
 
-# ../../toml/parser.py
-TomlParseFloat = ta.Callable[[str], ta.Any]
-TomlKey = ta.Tuple[str, ...]
-TomlPos = int  # ta.TypeAlias
-
-# ../../versioning/versions.py
+# ../../packaging/versions.py
 VersionLocalType = ta.Tuple[ta.Union[int, str], ...]
 VersionCmpPrePostDevType = ta.Union['InfinityVersionType', 'NegativeInfinityVersionType', ta.Tuple[str, int]]
 _VersionCmpLocalType0 = ta.Tuple[ta.Union[ta.Tuple[int, str], ta.Tuple['NegativeInfinityVersionType', ta.Union[int, str]]], ...]  # noqa
@@ -90,10 +85,15 @@ VersionCmpLocalType = ta.Union['NegativeInfinityVersionType', _VersionCmpLocalTy
 VersionCmpKey = ta.Tuple[int, ta.Tuple[int, ...], VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpPrePostDevType, VersionCmpLocalType]  # noqa
 VersionComparisonMethod = ta.Callable[[VersionCmpKey, VersionCmpKey], bool]
 
+# ../../toml/parser.py
+TomlParseFloat = ta.Callable[[str], ta.Any]
+TomlKey = ta.Tuple[str, ...]
+TomlPos = int  # ta.TypeAlias
+
 # ../../../omlish/lite/check.py
 T = ta.TypeVar('T')
 
-# ../../versioning/specifiers.py
+# ../../packaging/specifiers.py
 UnparsedVersion = ta.Union['Version', str]
 UnparsedVersionVar = ta.TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
 CallableVersionOperator = ta.Callable[['Version', str], bool]
@@ -270,1340 +270,1340 @@ def get_git_revision(
 
 
 ########################################
-# ../../toml/parser.py
-# SPDX-License-Identifier: MIT
-# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
-# Licensed to PSF under a Contributor Agreement.
-#
-# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
-# --------------------------------------------
-#
-# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
-# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
-# documentation.
-#
-# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
-# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
-# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
-# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
-# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation; All
-# Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee.
-#
-# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
-# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
-# any such work a brief summary of the changes made to Python.
-#
-# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
-# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
-# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
-# RIGHTS.
-#
-# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
-# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
-# ADVISED OF THE POSSIBILITY THEREOF.
+# ../../packaging/versions.py
+# Copyright (c) Donald Stufft and individual contributors.
+# All rights reserved.
 #
-# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
 #
-# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
-# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
-# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#     1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+#        following disclaimer.
 #
-# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
-# License Agreement.
+#     2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#        following disclaimer in the documentation and/or other materials provided with the distribution.
 #
-# https://github.com/python/cpython/blob/f5009b69e0cd94b990270e04e65b9d4d2b365844/Lib/tomllib/_parser.py
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This file is dual licensed under the terms of the
+# Apache License, Version 2.0, and the BSD License. See the LICENSE file in the root of this repository for complete
+# details.
+# https://github.com/pypa/packaging/blob/2c885fe91a54559e2382902dce28428ad2887be5/src/packaging/version.py
 
 
 ##
 
 
-_TOML_TIME_RE_STR = r'([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?'
+class InfinityVersionType:
+    def __repr__(self) -> str:
+        return 'Infinity'
 
-TOML_RE_NUMBER = re.compile(
-    r"""
-0
-(?:
-    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
-    |
-    b[01](?:_?[01])*                 # bin
-    |
-    o[0-7](?:_?[0-7])*               # oct
-)
-|
-[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
-(?P<floatpart>
-    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
-    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
-)
-""",
-    flags=re.VERBOSE,
-)
-TOML_RE_LOCALTIME = re.compile(_TOML_TIME_RE_STR)
-TOML_RE_DATETIME = re.compile(
-    rf"""
-([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
-(?:
-    [Tt ]
-    {_TOML_TIME_RE_STR}
-    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
-)?
-""",
-    flags=re.VERBOSE,
-)
+    def __hash__(self) -> int:
+        return hash(repr(self))
 
+    def __lt__(self, other: object) -> bool:
+        return False
 
-def toml_match_to_datetime(match: re.Match) -> ta.Union[datetime.datetime, datetime.date]:
-    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
+    def __le__(self, other: object) -> bool:
+        return False
 
-    Raises ValueError if the match does not correspond to a valid date or datetime.
-    """
-    (
-        year_str,
-        month_str,
-        day_str,
-        hour_str,
-        minute_str,
-        sec_str,
-        micros_str,
-        zulu_time,
-        offset_sign_str,
-        offset_hour_str,
-        offset_minute_str,
-    ) = match.groups()
-    year, month, day = int(year_str), int(month_str), int(day_str)
-    if hour_str is None:
-        return datetime.date(year, month, day)
-    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
-    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
-    if offset_sign_str:
-        tz: ta.Optional[datetime.tzinfo] = toml_cached_tz(
-            offset_hour_str, offset_minute_str, offset_sign_str,
-        )
-    elif zulu_time:
-        tz = datetime.UTC
-    else:  # local date-time
-        tz = None
-    return datetime.datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, self.__class__)
 
+    def __gt__(self, other: object) -> bool:
+        return True
 
-@functools.lru_cache()  # noqa
-def toml_cached_tz(hour_str: str, minute_str: str, sign_str: str) -> datetime.timezone:
-    sign = 1 if sign_str == '+' else -1
-    return datetime.timezone(
-        datetime.timedelta(
-            hours=sign * int(hour_str),
-            minutes=sign * int(minute_str),
-        ),
-    )
+    def __ge__(self, other: object) -> bool:
+        return True
 
+    def __neg__(self: object) -> 'NegativeInfinityVersionType':
+        return NegativeInfinityVersion
 
-def toml_match_to_localtime(match: re.Match) -> datetime.time:
-    hour_str, minute_str, sec_str, micros_str = match.groups()
-    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
-    return datetime.time(int(hour_str), int(minute_str), int(sec_str), micros)
 
+InfinityVersion = InfinityVersionType()
 
-def toml_match_to_number(match: re.Match, parse_float: TomlParseFloat) -> ta.Any:
-    if match.group('floatpart'):
-        return parse_float(match.group())
-    return int(match.group(), 0)
 
+class NegativeInfinityVersionType:
+    def __repr__(self) -> str:
+        return '-Infinity'
 
-TOML_ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
+    def __hash__(self) -> int:
+        return hash(repr(self))
 
-# Neither of these sets include quotation mark or backslash. They are currently handled as separate cases in the parser
-# functions.
-TOML_ILLEGAL_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t')
-TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t\n')
+    def __lt__(self, other: object) -> bool:
+        return True
 
-TOML_ILLEGAL_LITERAL_STR_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
-TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
+    def __le__(self, other: object) -> bool:
+        return True
 
-TOML_ILLEGAL_COMMENT_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, self.__class__)
 
-TOML_WS = frozenset(' \t')
-TOML_WS_AND_NEWLINE = TOML_WS | frozenset('\n')
-TOML_BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + '-_')
-TOML_KEY_INITIAL_CHARS = TOML_BARE_KEY_CHARS | frozenset("\"'")
-TOML_HEXDIGIT_CHARS = frozenset(string.hexdigits)
+    def __gt__(self, other: object) -> bool:
+        return False
 
-TOML_BASIC_STR_ESCAPE_REPLACEMENTS = types.MappingProxyType(
-    {
-        '\\b': '\u0008',  # backspace
-        '\\t': '\u0009',  # tab
-        '\\n': '\u000A',  # linefeed
-        '\\f': '\u000C',  # form feed
-        '\\r': '\u000D',  # carriage return
-        '\\"': '\u0022',  # quote
-        '\\\\': '\u005C',  # backslash
-    },
-)
+    def __ge__(self, other: object) -> bool:
+        return False
 
+    def __neg__(self: object) -> InfinityVersionType:
+        return InfinityVersion
 
-class TomlDecodeError(ValueError):
-    """An error raised if a document is not valid TOML."""
 
+NegativeInfinityVersion = NegativeInfinityVersionType()
 
-def toml_load(fp: ta.BinaryIO, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:
-    """Parse TOML from a binary file object."""
-    b = fp.read()
-    try:
-        s = b.decode()
-    except AttributeError:
-        raise TypeError("File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`") from None
-    return toml_loads(s, parse_float=parse_float)
 
+##
 
-def toml_loads(s: str, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:  # noqa: C901
-    """Parse TOML from a string."""
 
-    # The spec allows converting "\r\n" to "\n", even in string literals. Let's do so to simplify parsing.
-    src = s.replace('\r\n', '\n')
-    pos = 0
-    out = TomlOutput(TomlNestedDict(), TomlFlags())
-    header: TomlKey = ()
-    parse_float = toml_make_safe_parse_float(parse_float)
+class _Version(ta.NamedTuple):
+    epoch: int
+    release: ta.Tuple[int, ...]
+    dev: ta.Optional[ta.Tuple[str, int]]
+    pre: ta.Optional[ta.Tuple[str, int]]
+    post: ta.Optional[ta.Tuple[str, int]]
+    local: ta.Optional[VersionLocalType]
 
-    # Parse one statement at a time (typically means one line in TOML source)
-    while True:
-        # 1. Skip line leading whitespace
-        pos = toml_skip_chars(src, pos, TOML_WS)
 
-        # 2. Parse rules. Expect one of the following:
-        #    - end of file
-        #    - end of line
-        #    - comment
-        #    - key/value pair
-        #    - append dict to list (and move to its namespace)
-        #    - create dict (and move to its namespace)
-        # Skip trailing whitespace when applicable.
-        try:
-            char = src[pos]
-        except IndexError:
-            break
-        if char == '\n':
-            pos += 1
-            continue
-        if char in TOML_KEY_INITIAL_CHARS:
-            pos = toml_key_value_rule(src, pos, out, header, parse_float)
-            pos = toml_skip_chars(src, pos, TOML_WS)
-        elif char == '[':
-            try:
-                second_char: ta.Optional[str] = src[pos + 1]
-            except IndexError:
-                second_char = None
-            out.flags.finalize_pending()
-            if second_char == '[':
-                pos, header = toml_create_list_rule(src, pos, out)
-            else:
-                pos, header = toml_create_dict_rule(src, pos, out)
-            pos = toml_skip_chars(src, pos, TOML_WS)
-        elif char != '#':
-            raise toml_suffixed_err(src, pos, 'Invalid statement')
+class InvalidVersion(ValueError):  # noqa
+    pass
 
-        # 3. Skip comment
-        pos = toml_skip_comment(src, pos)
 
-        # 4. Expect end of line or end of file
-        try:
-            char = src[pos]
-        except IndexError:
-            break
-        if char != '\n':
-            raise toml_suffixed_err(
-                src, pos, 'Expected newline or end of document after a statement',
-            )
-        pos += 1
+class _BaseVersion:
+    _key: ta.Tuple[ta.Any, ...]
 
-    return out.data.dict
+    def __hash__(self) -> int:
+        return hash(self._key)
 
+    def __lt__(self, other: '_BaseVersion') -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented  # type: ignore
+        return self._key < other._key
 
-class TomlFlags:
-    """Flags that map to parsed keys/namespaces."""
+    def __le__(self, other: '_BaseVersion') -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented  # type: ignore
+        return self._key <= other._key
 
-    # Marks an immutable namespace (inline array or inline table).
-    FROZEN = 0
-    # Marks a nest that has been explicitly created and can no longer be opened using the "[table]" syntax.
-    EXPLICIT_NEST = 1
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+        return self._key == other._key
 
-    def __init__(self) -> None:
-        self._flags: ta.Dict[str, dict] = {}
-        self._pending_flags: ta.Set[ta.Tuple[TomlKey, int]] = set()
+    def __ge__(self, other: '_BaseVersion') -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented  # type: ignore
+        return self._key >= other._key
 
-    def add_pending(self, key: TomlKey, flag: int) -> None:
-        self._pending_flags.add((key, flag))
+    def __gt__(self, other: '_BaseVersion') -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented  # type: ignore
+        return self._key > other._key
 
-    def finalize_pending(self) -> None:
-        for key, flag in self._pending_flags:
-            self.set(key, flag, recursive=False)
-        self._pending_flags.clear()
+    def __ne__(self, other: object) -> bool:
+        if not isinstance(other, _BaseVersion):
+            return NotImplemented
+        return self._key != other._key
 
-    def unset_all(self, key: TomlKey) -> None:
-        cont = self._flags
-        for k in key[:-1]:
-            if k not in cont:
-                return
-            cont = cont[k]['nested']
-        cont.pop(key[-1], None)
 
-    def set(self, key: TomlKey, flag: int, *, recursive: bool) -> None:  # noqa: A003
-        cont = self._flags
-        key_parent, key_stem = key[:-1], key[-1]
-        for k in key_parent:
-            if k not in cont:
-                cont[k] = {'flags': set(), 'recursive_flags': set(), 'nested': {}}
-            cont = cont[k]['nested']
-        if key_stem not in cont:
-            cont[key_stem] = {'flags': set(), 'recursive_flags': set(), 'nested': {}}
-        cont[key_stem]['recursive_flags' if recursive else 'flags'].add(flag)
+_VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?
+        (?P<release>[0-9]+(?:\.[0-9]+)*)
+        (?P<pre>
+            [-_\.]?
+            (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc)
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?
+"""
 
-    def is_(self, key: TomlKey, flag: int) -> bool:
-        if not key:
-            return False  # document root has no flags
-        cont = self._flags
-        for k in key[:-1]:
-            if k not in cont:
-                return False
-            inner_cont = cont[k]
-            if flag in inner_cont['recursive_flags']:
-                return True
-            cont = inner_cont['nested']
-        key_stem = key[-1]
-        if key_stem in cont:
-            cont = cont[key_stem]
-            return flag in cont['flags'] or flag in cont['recursive_flags']
-        return False
+VERSION_PATTERN = _VERSION_PATTERN
 
 
-class TomlNestedDict:
-    def __init__(self) -> None:
-        # The parsed content of the TOML document
-        self.dict: ta.Dict[str, ta.Any] = {}
+class Version(_BaseVersion):
+    _regex = re.compile(r'^\s*' + VERSION_PATTERN + r'\s*$', re.VERBOSE | re.IGNORECASE)
+    _key: VersionCmpKey
 
-    def get_or_create_nest(
-            self,
-            key: TomlKey,
-            *,
-            access_lists: bool = True,
-    ) -> dict:
-        cont: ta.Any = self.dict
-        for k in key:
-            if k not in cont:
-                cont[k] = {}
-            cont = cont[k]
-            if access_lists and isinstance(cont, list):
-                cont = cont[-1]
-            if not isinstance(cont, dict):
-                raise KeyError('There is no nest behind this key')
-        return cont
+    def __init__(self, version: str) -> None:
+        match = self._regex.search(version)
+        if not match:
+            raise InvalidVersion(f"Invalid version: '{version}'")
 
-    def append_nest_to_list(self, key: TomlKey) -> None:
-        cont = self.get_or_create_nest(key[:-1])
-        last_key = key[-1]
-        if last_key in cont:
-            list_ = cont[last_key]
-            if not isinstance(list_, list):
-                raise KeyError('An object other than list found behind this key')
-            list_.append({})
-        else:
-            cont[last_key] = [{}]
+        self._version = _Version(
+            epoch=int(match.group('epoch')) if match.group('epoch') else 0,
+            release=tuple(int(i) for i in match.group('release').split('.')),
+            pre=_parse_letter_version(match.group('pre_l'), match.group('pre_n')),
+            post=_parse_letter_version(match.group('post_l'), match.group('post_n1') or match.group('post_n2')),
+            dev=_parse_letter_version(match.group('dev_l'), match.group('dev_n')),
+            local=_parse_local_version(match.group('local')),
+        )
 
+        self._key = _version_cmpkey(
+            self._version.epoch,
+            self._version.release,
+            self._version.pre,
+            self._version.post,
+            self._version.dev,
+            self._version.local,
+        )
 
-class TomlOutput(ta.NamedTuple):
-    data: TomlNestedDict
-    flags: TomlFlags
+    def __repr__(self) -> str:
+        return f"<Version('{self}')>"
 
+    def __str__(self) -> str:
+        parts = []
 
-def toml_skip_chars(src: str, pos: TomlPos, chars: ta.Iterable[str]) -> TomlPos:
-    try:
-        while src[pos] in chars:
-            pos += 1
-    except IndexError:
-        pass
-    return pos
+        if self.epoch != 0:
+            parts.append(f'{self.epoch}!')
 
+        parts.append('.'.join(str(x) for x in self.release))
 
-def toml_skip_until(
-        src: str,
-        pos: TomlPos,
-        expect: str,
-        *,
-        error_on: ta.FrozenSet[str],
-        error_on_eof: bool,
-) -> TomlPos:
-    try:
-        new_pos = src.index(expect, pos)
-    except ValueError:
-        new_pos = len(src)
-        if error_on_eof:
-            raise toml_suffixed_err(src, new_pos, f'Expected {expect!r}') from None
+        if self.pre is not None:
+            parts.append(''.join(str(x) for x in self.pre))
 
-    if not error_on.isdisjoint(src[pos:new_pos]):
-        while src[pos] not in error_on:
-            pos += 1
-        raise toml_suffixed_err(src, pos, f'Found invalid character {src[pos]!r}')
-    return new_pos
+        if self.post is not None:
+            parts.append(f'.post{self.post}')
 
+        if self.dev is not None:
+            parts.append(f'.dev{self.dev}')
 
-def toml_skip_comment(src: str, pos: TomlPos) -> TomlPos:
-    try:
-        char: ta.Optional[str] = src[pos]
-    except IndexError:
-        char = None
-    if char == '#':
-        return toml_skip_until(
-            src, pos + 1, '\n', error_on=TOML_ILLEGAL_COMMENT_CHARS, error_on_eof=False,
-        )
-    return pos
+        if self.local is not None:
+            parts.append(f'+{self.local}')
 
+        return ''.join(parts)
 
-def toml_skip_comments_and_array_ws(src: str, pos: TomlPos) -> TomlPos:
-    while True:
-        pos_before_skip = pos
-        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
-        pos = toml_skip_comment(src, pos)
-        if pos == pos_before_skip:
-            return pos
+    @property
+    def epoch(self) -> int:
+        return self._version.epoch
 
+    @property
+    def release(self) -> ta.Tuple[int, ...]:
+        return self._version.release
 
-def toml_create_dict_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
-    pos += 1  # Skip "["
-    pos = toml_skip_chars(src, pos, TOML_WS)
-    pos, key = toml_parse_key(src, pos)
+    @property
+    def pre(self) -> ta.Optional[ta.Tuple[str, int]]:
+        return self._version.pre
 
-    if out.flags.is_(key, TomlFlags.EXPLICIT_NEST) or out.flags.is_(key, TomlFlags.FROZEN):
-        raise toml_suffixed_err(src, pos, f'Cannot declare {key} twice')
-    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
-    try:
-        out.data.get_or_create_nest(key)
-    except KeyError:
-        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+    @property
+    def post(self) -> ta.Optional[int]:
+        return self._version.post[1] if self._version.post else None
 
-    if not src.startswith(']', pos):
-        raise toml_suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
-    return pos + 1, key
+    @property
+    def dev(self) -> ta.Optional[int]:
+        return self._version.dev[1] if self._version.dev else None
 
+    @property
+    def local(self) -> ta.Optional[str]:
+        if self._version.local:
+            return '.'.join(str(x) for x in self._version.local)
+        else:
+            return None
 
-def toml_create_list_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
-    pos += 2  # Skip "[["
-    pos = toml_skip_chars(src, pos, TOML_WS)
-    pos, key = toml_parse_key(src, pos)
+    @property
+    def public(self) -> str:
+        return str(self).split('+', 1)[0]
 
-    if out.flags.is_(key, TomlFlags.FROZEN):
-        raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
-    # Free the namespace now that it points to another empty list item...
-    out.flags.unset_all(key)
-    # ...but this key precisely is still prohibited from table declaration
-    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
-    try:
-        out.data.append_nest_to_list(key)
-    except KeyError:
-        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+    @property
+    def base_version(self) -> str:
+        parts = []
 
-    if not src.startswith(']]', pos):
-        raise toml_suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
-    return pos + 2, key
+        if self.epoch != 0:
+            parts.append(f'{self.epoch}!')
 
+        parts.append('.'.join(str(x) for x in self.release))
 
-def toml_key_value_rule(
-        src: str,
-        pos: TomlPos,
-        out: TomlOutput,
-        header: TomlKey,
-        parse_float: TomlParseFloat,
-) -> TomlPos:
-    pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
-    key_parent, key_stem = key[:-1], key[-1]
-    abs_key_parent = header + key_parent
+        return ''.join(parts)
 
-    relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
-    for cont_key in relative_path_cont_keys:
-        # Check that dotted key syntax does not redefine an existing table
-        if out.flags.is_(cont_key, TomlFlags.EXPLICIT_NEST):
-            raise toml_suffixed_err(src, pos, f'Cannot redefine namespace {cont_key}')
-        # Containers in the relative path can't be opened with the table syntax or dotted key/value syntax in following
-        # table sections.
-        out.flags.add_pending(cont_key, TomlFlags.EXPLICIT_NEST)
+    @property
+    def is_prerelease(self) -> bool:
+        return self.dev is not None or self.pre is not None
 
-    if out.flags.is_(abs_key_parent, TomlFlags.FROZEN):
-        raise toml_suffixed_err(
-            src,
-            pos,
-            f'Cannot mutate immutable namespace {abs_key_parent}',
-        )
+    @property
+    def is_postrelease(self) -> bool:
+        return self.post is not None
 
-    try:
-        nest = out.data.get_or_create_nest(abs_key_parent)
-    except KeyError:
-        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
-    if key_stem in nest:
-        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value')
-    # Mark inline table and array namespaces recursively immutable
-    if isinstance(value, (dict, list)):
-        out.flags.set(header + key, TomlFlags.FROZEN, recursive=True)
-    nest[key_stem] = value
-    return pos
+    @property
+    def is_devrelease(self) -> bool:
+        return self.dev is not None
 
+    @property
+    def major(self) -> int:
+        return self.release[0] if len(self.release) >= 1 else 0
 
-def toml_parse_key_value_pair(
-        src: str,
-        pos: TomlPos,
-        parse_float: TomlParseFloat,
-) -> ta.Tuple[TomlPos, TomlKey, ta.Any]:
-    pos, key = toml_parse_key(src, pos)
-    try:
-        char: ta.Optional[str] = src[pos]
-    except IndexError:
-        char = None
-    if char != '=':
-        raise toml_suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
-    pos += 1
-    pos = toml_skip_chars(src, pos, TOML_WS)
-    pos, value = toml_parse_value(src, pos, parse_float)
-    return pos, key, value
+    @property
+    def minor(self) -> int:
+        return self.release[1] if len(self.release) >= 2 else 0
 
+    @property
+    def micro(self) -> int:
+        return self.release[2] if len(self.release) >= 3 else 0
 
-def toml_parse_key(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, TomlKey]:
-    pos, key_part = toml_parse_key_part(src, pos)
-    key: TomlKey = (key_part,)
-    pos = toml_skip_chars(src, pos, TOML_WS)
-    while True:
-        try:
-            char: ta.Optional[str] = src[pos]
-        except IndexError:
-            char = None
-        if char != '.':
-            return pos, key
-        pos += 1
-        pos = toml_skip_chars(src, pos, TOML_WS)
-        pos, key_part = toml_parse_key_part(src, pos)
-        key += (key_part,)
-        pos = toml_skip_chars(src, pos, TOML_WS)
 
+def _parse_letter_version(
+        letter: ta.Optional[str],
+        number: ta.Union[str, bytes, ta.SupportsInt, None],
+) -> ta.Optional[ta.Tuple[str, int]]:
+    if letter:
+        if number is None:
+            number = 0
 
-def toml_parse_key_part(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
-    try:
-        char: ta.Optional[str] = src[pos]
-    except IndexError:
-        char = None
-    if char in TOML_BARE_KEY_CHARS:
-        start_pos = pos
-        pos = toml_skip_chars(src, pos, TOML_BARE_KEY_CHARS)
-        return pos, src[start_pos:pos]
-    if char == "'":
-        return toml_parse_literal_str(src, pos)
-    if char == '"':
-        return toml_parse_one_line_basic_str(src, pos)
-    raise toml_suffixed_err(src, pos, 'Invalid initial character for a key part')
+        letter = letter.lower()
+        if letter == 'alpha':
+            letter = 'a'
+        elif letter == 'beta':
+            letter = 'b'
+        elif letter in ['c', 'pre', 'preview']:
+            letter = 'rc'
+        elif letter in ['rev', 'r']:
+            letter = 'post'
 
+        return letter, int(number)
+    if not letter and number:
+        letter = 'post'
+        return letter, int(number)
 
-def toml_parse_one_line_basic_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
-    pos += 1
-    return toml_parse_basic_str(src, pos, multiline=False)
+    return None
 
 
-def toml_parse_array(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, list]:
-    pos += 1
-    array: list = []
+_local_version_separators = re.compile(r'[\._-]')
 
-    pos = toml_skip_comments_and_array_ws(src, pos)
-    if src.startswith(']', pos):
-        return pos + 1, array
-    while True:
-        pos, val = toml_parse_value(src, pos, parse_float)
-        array.append(val)
-        pos = toml_skip_comments_and_array_ws(src, pos)
 
-        c = src[pos:pos + 1]
-        if c == ']':
-            return pos + 1, array
-        if c != ',':
-            raise toml_suffixed_err(src, pos, 'Unclosed array')
-        pos += 1
+def _parse_local_version(local: ta.Optional[str]) -> ta.Optional[VersionLocalType]:
+    if local is not None:
+        return tuple(
+            part.lower() if not part.isdigit() else int(part)
+            for part in _local_version_separators.split(local)
+        )
+    return None
 
-        pos = toml_skip_comments_and_array_ws(src, pos)
-        if src.startswith(']', pos):
-            return pos + 1, array
 
+def _version_cmpkey(
+    epoch: int,
+    release: ta.Tuple[int, ...],
+    pre: ta.Optional[ta.Tuple[str, int]],
+    post: ta.Optional[ta.Tuple[str, int]],
+    dev: ta.Optional[ta.Tuple[str, int]],
+    local: ta.Optional[VersionLocalType],
+) -> VersionCmpKey:
+    _release = tuple(reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release)))))
 
-def toml_parse_inline_table(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, dict]:
-    pos += 1
-    nested_dict = TomlNestedDict()
-    flags = TomlFlags()
+    if pre is None and post is None and dev is not None:
+        _pre: VersionCmpPrePostDevType = NegativeInfinityVersion
+    elif pre is None:
+        _pre = InfinityVersion
+    else:
+        _pre = pre
 
-    pos = toml_skip_chars(src, pos, TOML_WS)
-    if src.startswith('}', pos):
-        return pos + 1, nested_dict.dict
-    while True:
-        pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
-        key_parent, key_stem = key[:-1], key[-1]
-        if flags.is_(key, TomlFlags.FROZEN):
-            raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
-        try:
-            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
-        except KeyError:
-            raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
-        if key_stem in nest:
-            raise toml_suffixed_err(src, pos, f'Duplicate inline table key {key_stem!r}')
-        nest[key_stem] = value
-        pos = toml_skip_chars(src, pos, TOML_WS)
-        c = src[pos:pos + 1]
-        if c == '}':
-            return pos + 1, nested_dict.dict
-        if c != ',':
-            raise toml_suffixed_err(src, pos, 'Unclosed inline table')
-        if isinstance(value, (dict, list)):
-            flags.set(key, TomlFlags.FROZEN, recursive=True)
-        pos += 1
-        pos = toml_skip_chars(src, pos, TOML_WS)
+    if post is None:
+        _post: VersionCmpPrePostDevType = NegativeInfinityVersion
+    else:
+        _post = post
 
+    if dev is None:
+        _dev: VersionCmpPrePostDevType = InfinityVersion
+    else:
+        _dev = dev
 
-def toml_parse_basic_str_escape(
-        src: str,
-        pos: TomlPos,
-        *,
-        multiline: bool = False,
-) -> ta.Tuple[TomlPos, str]:
-    escape_id = src[pos:pos + 2]
-    pos += 2
-    if multiline and escape_id in {'\\ ', '\\\t', '\\\n'}:
-        # Skip whitespace until next non-whitespace character or end of the doc. Error if non-whitespace is found before
-        # newline.
-        if escape_id != '\\\n':
-            pos = toml_skip_chars(src, pos, TOML_WS)
-            try:
-                char = src[pos]
-            except IndexError:
-                return pos, ''
-            if char != '\n':
-                raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string")
-            pos += 1
-        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
-        return pos, ''
-    if escape_id == '\\u':
-        return toml_parse_hex_char(src, pos, 4)
-    if escape_id == '\\U':
-        return toml_parse_hex_char(src, pos, 8)
-    try:
-        return pos, TOML_BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
-    except KeyError:
-        raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string") from None
-
-
-def toml_parse_basic_str_escape_multiline(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
-    return toml_parse_basic_str_escape(src, pos, multiline=True)
+    if local is None:
+        _local: VersionCmpLocalType = NegativeInfinityVersion
+    else:
+        _local = tuple((i, '') if isinstance(i, int) else (NegativeInfinityVersion, i) for i in local)
 
+    return epoch, _release, _pre, _post, _dev, _local
 
-def toml_parse_hex_char(src: str, pos: TomlPos, hex_len: int) -> ta.Tuple[TomlPos, str]:
-    hex_str = src[pos:pos + hex_len]
-    if len(hex_str) != hex_len or not TOML_HEXDIGIT_CHARS.issuperset(hex_str):
-        raise toml_suffixed_err(src, pos, 'Invalid hex value')
-    pos += hex_len
-    hex_int = int(hex_str, 16)
-    if not toml_is_unicode_scalar_value(hex_int):
-        raise toml_suffixed_err(src, pos, 'Escaped character is not a Unicode scalar value')
-    return pos, chr(hex_int)
 
+##
 
-def toml_parse_literal_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
-    pos += 1  # Skip starting apostrophe
-    start_pos = pos
-    pos = toml_skip_until(
-        src, pos, "'", error_on=TOML_ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True,
-    )
-    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
 
+def canonicalize_version(
+        version: ta.Union[Version, str],
+        *,
+        strip_trailing_zero: bool = True,
+) -> str:
+    if isinstance(version, str):
+        try:
+            parsed = Version(version)
+        except InvalidVersion:
+            return version
+    else:
+        parsed = version
 
-def toml_parse_multiline_str(src: str, pos: TomlPos, *, literal: bool) -> ta.Tuple[TomlPos, str]:
-    pos += 3
-    if src.startswith('\n', pos):
-        pos += 1
+    parts = []
 
-    if literal:
-        delim = "'"
-        end_pos = toml_skip_until(
-            src,
-            pos,
-            "'''",
-            error_on=TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
-            error_on_eof=True,
-        )
-        result = src[pos:end_pos]
-        pos = end_pos + 3
-    else:
-        delim = '"'
-        pos, result = toml_parse_basic_str(src, pos, multiline=True)
+    if parsed.epoch != 0:
+        parts.append(f'{parsed.epoch}!')
 
-    # Add at maximum two extra apostrophes/quotes if the end sequence is 4 or 5 chars long instead of just 3.
-    if not src.startswith(delim, pos):
-        return pos, result
-    pos += 1
-    if not src.startswith(delim, pos):
-        return pos, result + delim
-    pos += 1
-    return pos, result + (delim * 2)
+    release_segment = '.'.join(str(x) for x in parsed.release)
+    if strip_trailing_zero:
+        release_segment = re.sub(r'(\.0)+$', '', release_segment)
+    parts.append(release_segment)
 
+    if parsed.pre is not None:
+        parts.append(''.join(str(x) for x in parsed.pre))
 
-def toml_parse_basic_str(src: str, pos: TomlPos, *, multiline: bool) -> ta.Tuple[TomlPos, str]:
-    if multiline:
-        error_on = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
-        parse_escapes = toml_parse_basic_str_escape_multiline
-    else:
-        error_on = TOML_ILLEGAL_BASIC_STR_CHARS
-        parse_escapes = toml_parse_basic_str_escape
-    result = ''
-    start_pos = pos
-    while True:
-        try:
-            char = src[pos]
-        except IndexError:
-            raise toml_suffixed_err(src, pos, 'Unterminated string') from None
-        if char == '"':
-            if not multiline:
-                return pos + 1, result + src[start_pos:pos]
-            if src.startswith('"""', pos):
-                return pos + 3, result + src[start_pos:pos]
-            pos += 1
-            continue
-        if char == '\\':
-            result += src[start_pos:pos]
-            pos, parsed_escape = parse_escapes(src, pos)
-            result += parsed_escape
-            start_pos = pos
-            continue
-        if char in error_on:
-            raise toml_suffixed_err(src, pos, f'Illegal character {char!r}')
-        pos += 1
+    if parsed.post is not None:
+        parts.append(f'.post{parsed.post}')
 
+    if parsed.dev is not None:
+        parts.append(f'.dev{parsed.dev}')
 
-def toml_parse_value(  # noqa: C901
-        src: str,
-        pos: TomlPos,
-        parse_float: TomlParseFloat,
-) -> ta.Tuple[TomlPos, ta.Any]:
-    try:
-        char: ta.Optional[str] = src[pos]
-    except IndexError:
-        char = None
+    if parsed.local is not None:
+        parts.append(f'+{parsed.local}')
 
-    # IMPORTANT: order conditions based on speed of checking and likelihood
+    return ''.join(parts)
 
-    # Basic strings
-    if char == '"':
-        if src.startswith('"""', pos):
-            return toml_parse_multiline_str(src, pos, literal=False)
-        return toml_parse_one_line_basic_str(src, pos)
 
-    # Literal strings
-    if char == "'":
-        if src.startswith("'''", pos):
-            return toml_parse_multiline_str(src, pos, literal=True)
-        return toml_parse_literal_str(src, pos)
+########################################
+# ../../toml/parser.py
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
+# Licensed to PSF under a Contributor Agreement.
+#
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation; All
+# Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
+#
+# https://github.com/python/cpython/blob/f5009b69e0cd94b990270e04e65b9d4d2b365844/Lib/tomllib/_parser.py
 
-    # Booleans
-    if char == 't':
-        if src.startswith('true', pos):
-            return pos + 4, True
-    if char == 'f':
-        if src.startswith('false', pos):
-            return pos + 5, False
 
-    # Arrays
-    if char == '[':
-        return toml_parse_array(src, pos, parse_float)
+##
 
-    # Inline tables
-    if char == '{':
-        return toml_parse_inline_table(src, pos, parse_float)
 
-    # Dates and times
-    datetime_match = TOML_RE_DATETIME.match(src, pos)
-    if datetime_match:
-        try:
-            datetime_obj = toml_match_to_datetime(datetime_match)
-        except ValueError as e:
-            raise toml_suffixed_err(src, pos, 'Invalid date or datetime') from e
-        return datetime_match.end(), datetime_obj
-    localtime_match = TOML_RE_LOCALTIME.match(src, pos)
-    if localtime_match:
-        return localtime_match.end(), toml_match_to_localtime(localtime_match)
+_TOML_TIME_RE_STR = r'([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?'
 
-    # Integers and "normal" floats. The regex will greedily match any type starting with a decimal char, so needs to be
-    # located after handling of dates and times.
-    number_match = TOML_RE_NUMBER.match(src, pos)
-    if number_match:
-        return number_match.end(), toml_match_to_number(number_match, parse_float)
+TOML_RE_NUMBER = re.compile(
+    r"""
+0
+(?:
+    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
+    |
+    b[01](?:_?[01])*                 # bin
+    |
+    o[0-7](?:_?[0-7])*               # oct
+)
+|
+[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
+(?P<floatpart>
+    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
+    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
+)
+""",
+    flags=re.VERBOSE,
+)
+TOML_RE_LOCALTIME = re.compile(_TOML_TIME_RE_STR)
+TOML_RE_DATETIME = re.compile(
+    rf"""
+([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
+(?:
+    [Tt ]
+    {_TOML_TIME_RE_STR}
+    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
+)?
+""",
+    flags=re.VERBOSE,
+)
 
-    # Special floats
-    first_three = src[pos:pos + 3]
-    if first_three in {'inf', 'nan'}:
-        return pos + 3, parse_float(first_three)
-    first_four = src[pos:pos + 4]
-    if first_four in {'-inf', '+inf', '-nan', '+nan'}:
-        return pos + 4, parse_float(first_four)
 
-    raise toml_suffixed_err(src, pos, 'Invalid value')
+def toml_match_to_datetime(match: re.Match) -> ta.Union[datetime.datetime, datetime.date]:
+    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.
 
+    Raises ValueError if the match does not correspond to a valid date or datetime.
+    """
+    (
+        year_str,
+        month_str,
+        day_str,
+        hour_str,
+        minute_str,
+        sec_str,
+        micros_str,
+        zulu_time,
+        offset_sign_str,
+        offset_hour_str,
+        offset_minute_str,
+    ) = match.groups()
+    year, month, day = int(year_str), int(month_str), int(day_str)
+    if hour_str is None:
+        return datetime.date(year, month, day)
+    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
+    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
+    if offset_sign_str:
+        tz: ta.Optional[datetime.tzinfo] = toml_cached_tz(
+            offset_hour_str, offset_minute_str, offset_sign_str,
+        )
+    elif zulu_time:
+        tz = datetime.UTC
+    else:  # local date-time
+        tz = None
+    return datetime.datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)
 
-def toml_suffixed_err(src: str, pos: TomlPos, msg: str) -> TomlDecodeError:
-    """Return a `TomlDecodeError` where error message is suffixed with coordinates in source."""
 
-    def coord_repr(src: str, pos: TomlPos) -> str:
-        if pos >= len(src):
-            return 'end of document'
-        line = src.count('\n', 0, pos) + 1
-        if line == 1:
-            column = pos + 1
-        else:
-            column = pos - src.rindex('\n', 0, pos)
-        return f'line {line}, column {column}'
+@functools.lru_cache()  # noqa
+def toml_cached_tz(hour_str: str, minute_str: str, sign_str: str) -> datetime.timezone:
+    sign = 1 if sign_str == '+' else -1
+    return datetime.timezone(
+        datetime.timedelta(
+            hours=sign * int(hour_str),
+            minutes=sign * int(minute_str),
+        ),
+    )
 
-    return TomlDecodeError(f'{msg} (at {coord_repr(src, pos)})')
 
+def toml_match_to_localtime(match: re.Match) -> datetime.time:
+    hour_str, minute_str, sec_str, micros_str = match.groups()
+    micros = int(micros_str.ljust(6, '0')) if micros_str else 0
+    return datetime.time(int(hour_str), int(minute_str), int(sec_str), micros)
 
-def toml_is_unicode_scalar_value(codepoint: int) -> bool:
-    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
 
+def toml_match_to_number(match: re.Match, parse_float: TomlParseFloat) -> ta.Any:
+    if match.group('floatpart'):
+        return parse_float(match.group())
+    return int(match.group(), 0)
 
-def toml_make_safe_parse_float(parse_float: TomlParseFloat) -> TomlParseFloat:
-    """A decorator to make `parse_float` safe.
 
-    `parse_float` must not return dicts or lists, because these types would be mixed with parsed TOML tables and arrays,
-    thus confusing the parser. The returned decorated callable raises `ValueError` instead of returning illegal types.
-    """
-    # The default `float` callable never returns illegal types. Optimize it.
-    if parse_float is float:
-        return float
+TOML_ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))
 
-    def safe_parse_float(float_str: str) -> ta.Any:
-        float_value = parse_float(float_str)
-        if isinstance(float_value, (dict, list)):
-            raise ValueError('parse_float must not return dicts or lists')  # noqa
-        return float_value
+# Neither of these sets include quotation mark or backslash. They are currently handled as separate cases in the parser
+# functions.
+TOML_ILLEGAL_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t')
+TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS = TOML_ASCII_CTRL - frozenset('\t\n')
 
-    return safe_parse_float
+TOML_ILLEGAL_LITERAL_STR_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
+TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
 
+TOML_ILLEGAL_COMMENT_CHARS = TOML_ILLEGAL_BASIC_STR_CHARS
 
-########################################
-# ../../toml/writer.py
+TOML_WS = frozenset(' \t')
+TOML_WS_AND_NEWLINE = TOML_WS | frozenset('\n')
+TOML_BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + '-_')
+TOML_KEY_INITIAL_CHARS = TOML_BARE_KEY_CHARS | frozenset("\"'")
+TOML_HEXDIGIT_CHARS = frozenset(string.hexdigits)
 
+TOML_BASIC_STR_ESCAPE_REPLACEMENTS = types.MappingProxyType(
+    {
+        '\\b': '\u0008',  # backspace
+        '\\t': '\u0009',  # tab
+        '\\n': '\u000A',  # linefeed
+        '\\f': '\u000C',  # form feed
+        '\\r': '\u000D',  # carriage return
+        '\\"': '\u0022',  # quote
+        '\\\\': '\u005C',  # backslash
+    },
+)
 
-class TomlWriter:
-    @dc.dataclass(frozen=True)
-    class Literal:
-        s: str
 
-    def __init__(self, out: ta.TextIO) -> None:
-        super().__init__()
-        self._out = out
+class TomlDecodeError(ValueError):
+    """An error raised if a document is not valid TOML."""
 
-        self._indent = 0
-        self._wrote_indent = False
 
-    #
+def toml_load(fp: ta.BinaryIO, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:
+    """Parse TOML from a binary file object."""
+    b = fp.read()
+    try:
+        s = b.decode()
+    except AttributeError:
+        raise TypeError("File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`") from None
+    return toml_loads(s, parse_float=parse_float)
 
-    def _w(self, s: str) -> None:
-        if not self._wrote_indent:
-            self._out.write('    ' * self._indent)
-            self._wrote_indent = True
-        self._out.write(s)
 
-    def _nl(self) -> None:
-        self._out.write('\n')
-        self._wrote_indent = False
+def toml_loads(s: str, /, *, parse_float: TomlParseFloat = float) -> ta.Dict[str, ta.Any]:  # noqa: C901
+    """Parse TOML from a string."""
 
-    def _needs_quote(self, s: str) -> bool:
-        return (
-            not s or
-            any(c in s for c in '\'"\n') or
-            s[0] not in string.ascii_letters
-        )
+    # The spec allows converting "\r\n" to "\n", even in string literals. Let's do so to simplify parsing.
+    src = s.replace('\r\n', '\n')
+    pos = 0
+    out = TomlOutput(TomlNestedDict(), TomlFlags())
+    header: TomlKey = ()
+    parse_float = toml_make_safe_parse_float(parse_float)
 
-    def _maybe_quote(self, s: str) -> str:
-        if self._needs_quote(s):
-            return repr(s)
-        else:
-            return s
+    # Parse one statement at a time (typically means one line in TOML source)
+    while True:
+        # 1. Skip line leading whitespace
+        pos = toml_skip_chars(src, pos, TOML_WS)
 
-    #
+        # 2. Parse rules. Expect one of the following:
+        #    - end of file
+        #    - end of line
+        #    - comment
+        #    - key/value pair
+        #    - append dict to list (and move to its namespace)
+        #    - create dict (and move to its namespace)
+        # Skip trailing whitespace when applicable.
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char == '\n':
+            pos += 1
+            continue
+        if char in TOML_KEY_INITIAL_CHARS:
+            pos = toml_key_value_rule(src, pos, out, header, parse_float)
+            pos = toml_skip_chars(src, pos, TOML_WS)
+        elif char == '[':
+            try:
+                second_char: ta.Optional[str] = src[pos + 1]
+            except IndexError:
+                second_char = None
+            out.flags.finalize_pending()
+            if second_char == '[':
+                pos, header = toml_create_list_rule(src, pos, out)
+            else:
+                pos, header = toml_create_dict_rule(src, pos, out)
+            pos = toml_skip_chars(src, pos, TOML_WS)
+        elif char != '#':
+            raise toml_suffixed_err(src, pos, 'Invalid statement')
 
-    def write_root(self, obj: ta.Mapping) -> None:
-        for i, (k, v) in enumerate(obj.items()):
-            if i:
-                self._nl()
-            self._w('[')
-            self._w(self._maybe_quote(k))
-            self._w(']')
-            self._nl()
-            self.write_table_contents(v)
+        # 3. Skip comment
+        pos = toml_skip_comment(src, pos)
 
-    def write_table_contents(self, obj: ta.Mapping) -> None:
-        for k, v in obj.items():
-            self.write_key(k)
-            self._w(' = ')
-            self.write_value(v)
-            self._nl()
+        # 4. Expect end of line or end of file
+        try:
+            char = src[pos]
+        except IndexError:
+            break
+        if char != '\n':
+            raise toml_suffixed_err(
+                src, pos, 'Expected newline or end of document after a statement',
+            )
+        pos += 1
 
-    def write_array(self, obj: ta.Sequence) -> None:
-        self._w('[')
-        self._nl()
-        self._indent += 1
-        for e in obj:
-            self.write_value(e)
-            self._w(',')
-            self._nl()
-        self._indent -= 1
-        self._w(']')
+    return out.data.dict
 
-    def write_inline_table(self, obj: ta.Mapping) -> None:
-        self._w('{')
-        for i, (k, v) in enumerate(obj.items()):
-            if i:
-                self._w(', ')
-            self.write_key(k)
-            self._w(' = ')
-            self.write_value(v)
-        self._w('}')
 
-    def write_inline_array(self, obj: ta.Sequence) -> None:
-        self._w('[')
-        for i, e in enumerate(obj):
-            if i:
-                self._w(', ')
-            self.write_value(e)
-        self._w(']')
+class TomlFlags:
+    """Flags that map to parsed keys/namespaces."""
 
-    def write_key(self, obj: ta.Any) -> None:
-        if isinstance(obj, TomlWriter.Literal):
-            self._w(obj.s)
-        elif isinstance(obj, str):
-            self._w(self._maybe_quote(obj.replace('_', '-')))
-        elif isinstance(obj, int):
-            self._w(repr(str(obj)))
-        else:
-            raise TypeError(obj)
+    # Marks an immutable namespace (inline array or inline table).
+    FROZEN = 0
+    # Marks a nest that has been explicitly created and can no longer be opened using the "[table]" syntax.
+    EXPLICIT_NEST = 1
 
-    def write_value(self, obj: ta.Any) -> None:
-        if isinstance(obj, bool):
-            self._w(str(obj).lower())
-        elif isinstance(obj, (str, int, float)):
-            self._w(repr(obj))
-        elif isinstance(obj, ta.Mapping):
-            self.write_inline_table(obj)
-        elif isinstance(obj, ta.Sequence):
-            if not obj:
-                self.write_inline_array(obj)
-            else:
-                self.write_array(obj)
-        else:
-            raise TypeError(obj)
+    def __init__(self) -> None:
+        self._flags: ta.Dict[str, dict] = {}
+        self._pending_flags: ta.Set[ta.Tuple[TomlKey, int]] = set()
 
+    def add_pending(self, key: TomlKey, flag: int) -> None:
+        self._pending_flags.add((key, flag))
 
-########################################
-# ../../versioning/versions.py
-# Copyright (c) Donald Stufft and individual contributors.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
-# following conditions are met:
-#
-#     1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
-#        following disclaimer.
-#
-#     2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
-#        following disclaimer in the documentation and/or other materials provided with the distribution.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
-# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This file is dual licensed under the terms of the
-# Apache License, Version 2.0, and the BSD License. See the LICENSE file in the root of this repository for complete
-# details.
-# https://github.com/pypa/packaging/blob/2c885fe91a54559e2382902dce28428ad2887be5/src/packaging/version.py
+    def finalize_pending(self) -> None:
+        for key, flag in self._pending_flags:
+            self.set(key, flag, recursive=False)
+        self._pending_flags.clear()
 
+    def unset_all(self, key: TomlKey) -> None:
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return
+            cont = cont[k]['nested']
+        cont.pop(key[-1], None)
 
-##
+    def set(self, key: TomlKey, flag: int, *, recursive: bool) -> None:  # noqa: A003
+        cont = self._flags
+        key_parent, key_stem = key[:-1], key[-1]
+        for k in key_parent:
+            if k not in cont:
+                cont[k] = {'flags': set(), 'recursive_flags': set(), 'nested': {}}
+            cont = cont[k]['nested']
+        if key_stem not in cont:
+            cont[key_stem] = {'flags': set(), 'recursive_flags': set(), 'nested': {}}
+        cont[key_stem]['recursive_flags' if recursive else 'flags'].add(flag)
 
+    def is_(self, key: TomlKey, flag: int) -> bool:
+        if not key:
+            return False  # document root has no flags
+        cont = self._flags
+        for k in key[:-1]:
+            if k not in cont:
+                return False
+            inner_cont = cont[k]
+            if flag in inner_cont['recursive_flags']:
+                return True
+            cont = inner_cont['nested']
+        key_stem = key[-1]
+        if key_stem in cont:
+            cont = cont[key_stem]
+            return flag in cont['flags'] or flag in cont['recursive_flags']
+        return False
 
-class InfinityVersionType:
-    def __repr__(self) -> str:
-        return 'Infinity'
 
-    def __hash__(self) -> int:
-        return hash(repr(self))
+class TomlNestedDict:
+    def __init__(self) -> None:
+        # The parsed content of the TOML document
+        self.dict: ta.Dict[str, ta.Any] = {}
 
-    def __lt__(self, other: object) -> bool:
-        return False
+    def get_or_create_nest(
+            self,
+            key: TomlKey,
+            *,
+            access_lists: bool = True,
+    ) -> dict:
+        cont: ta.Any = self.dict
+        for k in key:
+            if k not in cont:
+                cont[k] = {}
+            cont = cont[k]
+            if access_lists and isinstance(cont, list):
+                cont = cont[-1]
+            if not isinstance(cont, dict):
+                raise KeyError('There is no nest behind this key')
+        return cont
 
-    def __le__(self, other: object) -> bool:
-        return False
+    def append_nest_to_list(self, key: TomlKey) -> None:
+        cont = self.get_or_create_nest(key[:-1])
+        last_key = key[-1]
+        if last_key in cont:
+            list_ = cont[last_key]
+            if not isinstance(list_, list):
+                raise KeyError('An object other than list found behind this key')
+            list_.append({})
+        else:
+            cont[last_key] = [{}]
 
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, self.__class__)
 
-    def __gt__(self, other: object) -> bool:
-        return True
+class TomlOutput(ta.NamedTuple):
+    data: TomlNestedDict
+    flags: TomlFlags
 
-    def __ge__(self, other: object) -> bool:
-        return True
 
-    def __neg__(self: object) -> 'NegativeInfinityVersionType':
-        return NegativeInfinityVersion
+def toml_skip_chars(src: str, pos: TomlPos, chars: ta.Iterable[str]) -> TomlPos:
+    try:
+        while src[pos] in chars:
+            pos += 1
+    except IndexError:
+        pass
+    return pos
 
 
-InfinityVersion = InfinityVersionType()
+def toml_skip_until(
+        src: str,
+        pos: TomlPos,
+        expect: str,
+        *,
+        error_on: ta.FrozenSet[str],
+        error_on_eof: bool,
+) -> TomlPos:
+    try:
+        new_pos = src.index(expect, pos)
+    except ValueError:
+        new_pos = len(src)
+        if error_on_eof:
+            raise toml_suffixed_err(src, new_pos, f'Expected {expect!r}') from None
 
+    if not error_on.isdisjoint(src[pos:new_pos]):
+        while src[pos] not in error_on:
+            pos += 1
+        raise toml_suffixed_err(src, pos, f'Found invalid character {src[pos]!r}')
+    return new_pos
 
-class NegativeInfinityVersionType:
-    def __repr__(self) -> str:
-        return '-Infinity'
 
-    def __hash__(self) -> int:
-        return hash(repr(self))
+def toml_skip_comment(src: str, pos: TomlPos) -> TomlPos:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char == '#':
+        return toml_skip_until(
+            src, pos + 1, '\n', error_on=TOML_ILLEGAL_COMMENT_CHARS, error_on_eof=False,
+        )
+    return pos
 
-    def __lt__(self, other: object) -> bool:
-        return True
 
-    def __le__(self, other: object) -> bool:
-        return True
+def toml_skip_comments_and_array_ws(src: str, pos: TomlPos) -> TomlPos:
+    while True:
+        pos_before_skip = pos
+        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        pos = toml_skip_comment(src, pos)
+        if pos == pos_before_skip:
+            return pos
 
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, self.__class__)
 
-    def __gt__(self, other: object) -> bool:
-        return False
+def toml_create_dict_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
+    pos += 1  # Skip "["
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, key = toml_parse_key(src, pos)
 
-    def __ge__(self, other: object) -> bool:
-        return False
+    if out.flags.is_(key, TomlFlags.EXPLICIT_NEST) or out.flags.is_(key, TomlFlags.FROZEN):
+        raise toml_suffixed_err(src, pos, f'Cannot declare {key} twice')
+    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.get_or_create_nest(key)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
 
-    def __neg__(self: object) -> InfinityVersionType:
-        return InfinityVersion
+    if not src.startswith(']', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
+    return pos + 1, key
 
 
-NegativeInfinityVersion = NegativeInfinityVersionType()
+def toml_create_list_rule(src: str, pos: TomlPos, out: TomlOutput) -> ta.Tuple[TomlPos, TomlKey]:
+    pos += 2  # Skip "[["
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, key = toml_parse_key(src, pos)
 
+    if out.flags.is_(key, TomlFlags.FROZEN):
+        raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
+    # Free the namespace now that it points to another empty list item...
+    out.flags.unset_all(key)
+    # ...but this key precisely is still prohibited from table declaration
+    out.flags.set(key, TomlFlags.EXPLICIT_NEST, recursive=False)
+    try:
+        out.data.append_nest_to_list(key)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
 
-##
+    if not src.startswith(']]', pos):
+        raise toml_suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
+    return pos + 2, key
 
 
-class _Version(ta.NamedTuple):
-    epoch: int
-    release: ta.Tuple[int, ...]
-    dev: ta.Optional[ta.Tuple[str, int]]
-    pre: ta.Optional[ta.Tuple[str, int]]
-    post: ta.Optional[ta.Tuple[str, int]]
-    local: ta.Optional[VersionLocalType]
+def toml_key_value_rule(
+        src: str,
+        pos: TomlPos,
+        out: TomlOutput,
+        header: TomlKey,
+        parse_float: TomlParseFloat,
+) -> TomlPos:
+    pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
+    key_parent, key_stem = key[:-1], key[-1]
+    abs_key_parent = header + key_parent
 
+    relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
+    for cont_key in relative_path_cont_keys:
+        # Check that dotted key syntax does not redefine an existing table
+        if out.flags.is_(cont_key, TomlFlags.EXPLICIT_NEST):
+            raise toml_suffixed_err(src, pos, f'Cannot redefine namespace {cont_key}')
+        # Containers in the relative path can't be opened with the table syntax or dotted key/value syntax in following
+        # table sections.
+        out.flags.add_pending(cont_key, TomlFlags.EXPLICIT_NEST)
+
+    if out.flags.is_(abs_key_parent, TomlFlags.FROZEN):
+        raise toml_suffixed_err(
+            src,
+            pos,
+            f'Cannot mutate immutable namespace {abs_key_parent}',
+        )
+
+    try:
+        nest = out.data.get_or_create_nest(abs_key_parent)
+    except KeyError:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+    if key_stem in nest:
+        raise toml_suffixed_err(src, pos, 'Cannot overwrite a value')
+    # Mark inline table and array namespaces recursively immutable
+    if isinstance(value, (dict, list)):
+        out.flags.set(header + key, TomlFlags.FROZEN, recursive=True)
+    nest[key_stem] = value
+    return pos
 
-class InvalidVersion(ValueError):  # noqa
-    pass
 
+def toml_parse_key_value_pair(
+        src: str,
+        pos: TomlPos,
+        parse_float: TomlParseFloat,
+) -> ta.Tuple[TomlPos, TomlKey, ta.Any]:
+    pos, key = toml_parse_key(src, pos)
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char != '=':
+        raise toml_suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
+    pos += 1
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    pos, value = toml_parse_value(src, pos, parse_float)
+    return pos, key, value
 
-class _BaseVersion:
-    _key: ta.Tuple[ta.Any, ...]
 
-    def __hash__(self) -> int:
-        return hash(self._key)
+def toml_parse_key(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, TomlKey]:
+    pos, key_part = toml_parse_key_part(src, pos)
+    key: TomlKey = (key_part,)
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    while True:
+        try:
+            char: ta.Optional[str] = src[pos]
+        except IndexError:
+            char = None
+        if char != '.':
+            return pos, key
+        pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS)
+        pos, key_part = toml_parse_key_part(src, pos)
+        key += (key_part,)
+        pos = toml_skip_chars(src, pos, TOML_WS)
 
-    def __lt__(self, other: '_BaseVersion') -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
-        return self._key < other._key
 
-    def __le__(self, other: '_BaseVersion') -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
-        return self._key <= other._key
+def toml_parse_key_part(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
+    if char in TOML_BARE_KEY_CHARS:
+        start_pos = pos
+        pos = toml_skip_chars(src, pos, TOML_BARE_KEY_CHARS)
+        return pos, src[start_pos:pos]
+    if char == "'":
+        return toml_parse_literal_str(src, pos)
+    if char == '"':
+        return toml_parse_one_line_basic_str(src, pos)
+    raise toml_suffixed_err(src, pos, 'Invalid initial character for a key part')
 
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-        return self._key == other._key
 
-    def __ge__(self, other: '_BaseVersion') -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
-        return self._key >= other._key
+def toml_parse_one_line_basic_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    pos += 1
+    return toml_parse_basic_str(src, pos, multiline=False)
 
-    def __gt__(self, other: '_BaseVersion') -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
-        return self._key > other._key
 
-    def __ne__(self, other: object) -> bool:
-        if not isinstance(other, _BaseVersion):
-            return NotImplemented
-        return self._key != other._key
+def toml_parse_array(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, list]:
+    pos += 1
+    array: list = []
 
+    pos = toml_skip_comments_and_array_ws(src, pos)
+    if src.startswith(']', pos):
+        return pos + 1, array
+    while True:
+        pos, val = toml_parse_value(src, pos, parse_float)
+        array.append(val)
+        pos = toml_skip_comments_and_array_ws(src, pos)
 
-_VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?
-        (?P<release>[0-9]+(?:\.[0-9]+)*)
-        (?P<pre>
-            [-_\.]?
-            (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc)
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?
-"""
+        c = src[pos:pos + 1]
+        if c == ']':
+            return pos + 1, array
+        if c != ',':
+            raise toml_suffixed_err(src, pos, 'Unclosed array')
+        pos += 1
 
-VERSION_PATTERN = _VERSION_PATTERN
+        pos = toml_skip_comments_and_array_ws(src, pos)
+        if src.startswith(']', pos):
+            return pos + 1, array
 
 
-class Version(_BaseVersion):
-    _regex = re.compile(r'^\s*' + VERSION_PATTERN + r'\s*$', re.VERBOSE | re.IGNORECASE)
-    _key: VersionCmpKey
+def toml_parse_inline_table(src: str, pos: TomlPos, parse_float: TomlParseFloat) -> ta.Tuple[TomlPos, dict]:
+    pos += 1
+    nested_dict = TomlNestedDict()
+    flags = TomlFlags()
 
-    def __init__(self, version: str) -> None:
-        match = self._regex.search(version)
-        if not match:
-            raise InvalidVersion(f"Invalid version: '{version}'")
+    pos = toml_skip_chars(src, pos, TOML_WS)
+    if src.startswith('}', pos):
+        return pos + 1, nested_dict.dict
+    while True:
+        pos, key, value = toml_parse_key_value_pair(src, pos, parse_float)
+        key_parent, key_stem = key[:-1], key[-1]
+        if flags.is_(key, TomlFlags.FROZEN):
+            raise toml_suffixed_err(src, pos, f'Cannot mutate immutable namespace {key}')
+        try:
+            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
+        except KeyError:
+            raise toml_suffixed_err(src, pos, 'Cannot overwrite a value') from None
+        if key_stem in nest:
+            raise toml_suffixed_err(src, pos, f'Duplicate inline table key {key_stem!r}')
+        nest[key_stem] = value
+        pos = toml_skip_chars(src, pos, TOML_WS)
+        c = src[pos:pos + 1]
+        if c == '}':
+            return pos + 1, nested_dict.dict
+        if c != ',':
+            raise toml_suffixed_err(src, pos, 'Unclosed inline table')
+        if isinstance(value, (dict, list)):
+            flags.set(key, TomlFlags.FROZEN, recursive=True)
+        pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS)
 
-        self._version = _Version(
-            epoch=int(match.group('epoch')) if match.group('epoch') else 0,
-            release=tuple(int(i) for i in match.group('release').split('.')),
-            pre=_parse_letter_version(match.group('pre_l'), match.group('pre_n')),
-            post=_parse_letter_version(match.group('post_l'), match.group('post_n1') or match.group('post_n2')),
-            dev=_parse_letter_version(match.group('dev_l'), match.group('dev_n')),
-            local=_parse_local_version(match.group('local')),
-        )
 
-        self._key = _version_cmpkey(
-            self._version.epoch,
-            self._version.release,
-            self._version.pre,
-            self._version.post,
-            self._version.dev,
-            self._version.local,
-        )
+def toml_parse_basic_str_escape(
+        src: str,
+        pos: TomlPos,
+        *,
+        multiline: bool = False,
+) -> ta.Tuple[TomlPos, str]:
+    escape_id = src[pos:pos + 2]
+    pos += 2
+    if multiline and escape_id in {'\\ ', '\\\t', '\\\n'}:
+        # Skip whitespace until next non-whitespace character or end of the doc. Error if non-whitespace is found before
+        # newline.
+        if escape_id != '\\\n':
+            pos = toml_skip_chars(src, pos, TOML_WS)
+            try:
+                char = src[pos]
+            except IndexError:
+                return pos, ''
+            if char != '\n':
+                raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string")
+            pos += 1
+        pos = toml_skip_chars(src, pos, TOML_WS_AND_NEWLINE)
+        return pos, ''
+    if escape_id == '\\u':
+        return toml_parse_hex_char(src, pos, 4)
+    if escape_id == '\\U':
+        return toml_parse_hex_char(src, pos, 8)
+    try:
+        return pos, TOML_BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
+    except KeyError:
+        raise toml_suffixed_err(src, pos, "Unescaped '\\' in a string") from None
 
-    def __repr__(self) -> str:
-        return f"<Version('{self}')>"
 
-    def __str__(self) -> str:
-        parts = []
+def toml_parse_basic_str_escape_multiline(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    return toml_parse_basic_str_escape(src, pos, multiline=True)
 
-        if self.epoch != 0:
-            parts.append(f'{self.epoch}!')
 
-        parts.append('.'.join(str(x) for x in self.release))
+def toml_parse_hex_char(src: str, pos: TomlPos, hex_len: int) -> ta.Tuple[TomlPos, str]:
+    hex_str = src[pos:pos + hex_len]
+    if len(hex_str) != hex_len or not TOML_HEXDIGIT_CHARS.issuperset(hex_str):
+        raise toml_suffixed_err(src, pos, 'Invalid hex value')
+    pos += hex_len
+    hex_int = int(hex_str, 16)
+    if not toml_is_unicode_scalar_value(hex_int):
+        raise toml_suffixed_err(src, pos, 'Escaped character is not a Unicode scalar value')
+    return pos, chr(hex_int)
 
-        if self.pre is not None:
-            parts.append(''.join(str(x) for x in self.pre))
 
-        if self.post is not None:
-            parts.append(f'.post{self.post}')
+def toml_parse_literal_str(src: str, pos: TomlPos) -> ta.Tuple[TomlPos, str]:
+    pos += 1  # Skip starting apostrophe
+    start_pos = pos
+    pos = toml_skip_until(
+        src, pos, "'", error_on=TOML_ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True,
+    )
+    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe
 
-        if self.dev is not None:
-            parts.append(f'.dev{self.dev}')
 
-        if self.local is not None:
-            parts.append(f'+{self.local}')
+def toml_parse_multiline_str(src: str, pos: TomlPos, *, literal: bool) -> ta.Tuple[TomlPos, str]:
+    pos += 3
+    if src.startswith('\n', pos):
+        pos += 1
 
-        return ''.join(parts)
+    if literal:
+        delim = "'"
+        end_pos = toml_skip_until(
+            src,
+            pos,
+            "'''",
+            error_on=TOML_ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
+            error_on_eof=True,
+        )
+        result = src[pos:end_pos]
+        pos = end_pos + 3
+    else:
+        delim = '"'
+        pos, result = toml_parse_basic_str(src, pos, multiline=True)
 
-    @property
-    def epoch(self) -> int:
-        return self._version.epoch
+    # Add at maximum two extra apostrophes/quotes if the end sequence is 4 or 5 chars long instead of just 3.
+    if not src.startswith(delim, pos):
+        return pos, result
+    pos += 1
+    if not src.startswith(delim, pos):
+        return pos, result + delim
+    pos += 1
+    return pos, result + (delim * 2)
 
-    @property
-    def release(self) -> ta.Tuple[int, ...]:
-        return self._version.release
 
-    @property
-    def pre(self) -> ta.Optional[ta.Tuple[str, int]]:
-        return self._version.pre
+def toml_parse_basic_str(src: str, pos: TomlPos, *, multiline: bool) -> ta.Tuple[TomlPos, str]:
+    if multiline:
+        error_on = TOML_ILLEGAL_MULTILINE_BASIC_STR_CHARS
+        parse_escapes = toml_parse_basic_str_escape_multiline
+    else:
+        error_on = TOML_ILLEGAL_BASIC_STR_CHARS
+        parse_escapes = toml_parse_basic_str_escape
+    result = ''
+    start_pos = pos
+    while True:
+        try:
+            char = src[pos]
+        except IndexError:
+            raise toml_suffixed_err(src, pos, 'Unterminated string') from None
+        if char == '"':
+            if not multiline:
+                return pos + 1, result + src[start_pos:pos]
+            if src.startswith('"""', pos):
+                return pos + 3, result + src[start_pos:pos]
+            pos += 1
+            continue
+        if char == '\\':
+            result += src[start_pos:pos]
+            pos, parsed_escape = parse_escapes(src, pos)
+            result += parsed_escape
+            start_pos = pos
+            continue
+        if char in error_on:
+            raise toml_suffixed_err(src, pos, f'Illegal character {char!r}')
+        pos += 1
 
-    @property
-    def post(self) -> ta.Optional[int]:
-        return self._version.post[1] if self._version.post else None
 
-    @property
-    def dev(self) -> ta.Optional[int]:
-        return self._version.dev[1] if self._version.dev else None
+def toml_parse_value(  # noqa: C901
+        src: str,
+        pos: TomlPos,
+        parse_float: TomlParseFloat,
+) -> ta.Tuple[TomlPos, ta.Any]:
+    try:
+        char: ta.Optional[str] = src[pos]
+    except IndexError:
+        char = None
 
-    @property
-    def local(self) -> ta.Optional[str]:
-        if self._version.local:
-            return '.'.join(str(x) for x in self._version.local)
-        else:
-            return None
+    # IMPORTANT: order conditions based on speed of checking and likelihood
 
-    @property
-    def public(self) -> str:
-        return str(self).split('+', 1)[0]
+    # Basic strings
+    if char == '"':
+        if src.startswith('"""', pos):
+            return toml_parse_multiline_str(src, pos, literal=False)
+        return toml_parse_one_line_basic_str(src, pos)
 
-    @property
-    def base_version(self) -> str:
-        parts = []
+    # Literal strings
+    if char == "'":
+        if src.startswith("'''", pos):
+            return toml_parse_multiline_str(src, pos, literal=True)
+        return toml_parse_literal_str(src, pos)
 
-        if self.epoch != 0:
-            parts.append(f'{self.epoch}!')
+    # Booleans
+    if char == 't':
+        if src.startswith('true', pos):
+            return pos + 4, True
+    if char == 'f':
+        if src.startswith('false', pos):
+            return pos + 5, False
 
-        parts.append('.'.join(str(x) for x in self.release))
+    # Arrays
+    if char == '[':
+        return toml_parse_array(src, pos, parse_float)
 
-        return ''.join(parts)
+    # Inline tables
+    if char == '{':
+        return toml_parse_inline_table(src, pos, parse_float)
 
-    @property
-    def is_prerelease(self) -> bool:
-        return self.dev is not None or self.pre is not None
+    # Dates and times
+    datetime_match = TOML_RE_DATETIME.match(src, pos)
+    if datetime_match:
+        try:
+            datetime_obj = toml_match_to_datetime(datetime_match)
+        except ValueError as e:
+            raise toml_suffixed_err(src, pos, 'Invalid date or datetime') from e
+        return datetime_match.end(), datetime_obj
+    localtime_match = TOML_RE_LOCALTIME.match(src, pos)
+    if localtime_match:
+        return localtime_match.end(), toml_match_to_localtime(localtime_match)
 
-    @property
-    def is_postrelease(self) -> bool:
-        return self.post is not None
+    # Integers and "normal" floats. The regex will greedily match any type starting with a decimal char, so needs to be
+    # located after handling of dates and times.
+    number_match = TOML_RE_NUMBER.match(src, pos)
+    if number_match:
+        return number_match.end(), toml_match_to_number(number_match, parse_float)
 
-    @property
-    def is_devrelease(self) -> bool:
-        return self.dev is not None
+    # Special floats
+    first_three = src[pos:pos + 3]
+    if first_three in {'inf', 'nan'}:
+        return pos + 3, parse_float(first_three)
+    first_four = src[pos:pos + 4]
+    if first_four in {'-inf', '+inf', '-nan', '+nan'}:
+        return pos + 4, parse_float(first_four)
 
-    @property
-    def major(self) -> int:
-        return self.release[0] if len(self.release) >= 1 else 0
+    raise toml_suffixed_err(src, pos, 'Invalid value')
 
-    @property
-    def minor(self) -> int:
-        return self.release[1] if len(self.release) >= 2 else 0
 
-    @property
-    def micro(self) -> int:
-        return self.release[2] if len(self.release) >= 3 else 0
+def toml_suffixed_err(src: str, pos: TomlPos, msg: str) -> TomlDecodeError:
+    """Return a `TomlDecodeError` where error message is suffixed with coordinates in source."""
 
+    def coord_repr(src: str, pos: TomlPos) -> str:
+        if pos >= len(src):
+            return 'end of document'
+        line = src.count('\n', 0, pos) + 1
+        if line == 1:
+            column = pos + 1
+        else:
+            column = pos - src.rindex('\n', 0, pos)
+        return f'line {line}, column {column}'
 
-def _parse_letter_version(
-        letter: ta.Optional[str],
-        number: ta.Union[str, bytes, ta.SupportsInt, None],
-) -> ta.Optional[ta.Tuple[str, int]]:
-    if letter:
-        if number is None:
-            number = 0
+    return TomlDecodeError(f'{msg} (at {coord_repr(src, pos)})')
 
-        letter = letter.lower()
-        if letter == 'alpha':
-            letter = 'a'
-        elif letter == 'beta':
-            letter = 'b'
-        elif letter in ['c', 'pre', 'preview']:
-            letter = 'rc'
-        elif letter in ['rev', 'r']:
-            letter = 'post'
 
-        return letter, int(number)
-    if not letter and number:
-        letter = 'post'
-        return letter, int(number)
+def toml_is_unicode_scalar_value(codepoint: int) -> bool:
+    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)
 
-    return None
 
+def toml_make_safe_parse_float(parse_float: TomlParseFloat) -> TomlParseFloat:
+    """A decorator to make `parse_float` safe.
 
-_local_version_separators = re.compile(r'[\._-]')
+    `parse_float` must not return dicts or lists, because these types would be mixed with parsed TOML tables and arrays,
+    thus confusing the parser. The returned decorated callable raises `ValueError` instead of returning illegal types.
+    """
+    # The default `float` callable never returns illegal types. Optimize it.
+    if parse_float is float:
+        return float
 
+    def safe_parse_float(float_str: str) -> ta.Any:
+        float_value = parse_float(float_str)
+        if isinstance(float_value, (dict, list)):
+            raise ValueError('parse_float must not return dicts or lists')  # noqa
+        return float_value
 
-def _parse_local_version(local: ta.Optional[str]) -> ta.Optional[VersionLocalType]:
-    if local is not None:
-        return tuple(
-            part.lower() if not part.isdigit() else int(part)
-            for part in _local_version_separators.split(local)
-        )
-    return None
+    return safe_parse_float
 
 
-def _version_cmpkey(
-    epoch: int,
-    release: ta.Tuple[int, ...],
-    pre: ta.Optional[ta.Tuple[str, int]],
-    post: ta.Optional[ta.Tuple[str, int]],
-    dev: ta.Optional[ta.Tuple[str, int]],
-    local: ta.Optional[VersionLocalType],
-) -> VersionCmpKey:
-    _release = tuple(reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release)))))
+########################################
+# ../../toml/writer.py
 
-    if pre is None and post is None and dev is not None:
-        _pre: VersionCmpPrePostDevType = NegativeInfinityVersion
-    elif pre is None:
-        _pre = InfinityVersion
-    else:
-        _pre = pre
 
-    if post is None:
-        _post: VersionCmpPrePostDevType = NegativeInfinityVersion
-    else:
-        _post = post
+class TomlWriter:
+    @dc.dataclass(frozen=True)
+    class Literal:
+        s: str
 
-    if dev is None:
-        _dev: VersionCmpPrePostDevType = InfinityVersion
-    else:
-        _dev = dev
+    def __init__(self, out: ta.TextIO) -> None:
+        super().__init__()
+        self._out = out
 
-    if local is None:
-        _local: VersionCmpLocalType = NegativeInfinityVersion
-    else:
-        _local = tuple((i, '') if isinstance(i, int) else (NegativeInfinityVersion, i) for i in local)
+        self._indent = 0
+        self._wrote_indent = False
 
-    return epoch, _release, _pre, _post, _dev, _local
+    #
 
+    def _w(self, s: str) -> None:
+        if not self._wrote_indent:
+            self._out.write('    ' * self._indent)
+            self._wrote_indent = True
+        self._out.write(s)
 
-##
+    def _nl(self) -> None:
+        self._out.write('\n')
+        self._wrote_indent = False
 
+    def _needs_quote(self, s: str) -> bool:
+        return (
+            not s or
+            any(c in s for c in '\'"\n') or
+            s[0] not in string.ascii_letters
+        )
 
-def canonicalize_version(
-        version: ta.Union[Version, str],
-        *,
-        strip_trailing_zero: bool = True,
-) -> str:
-    if isinstance(version, str):
-        try:
-            parsed = Version(version)
-        except InvalidVersion:
-            return version
-    else:
-        parsed = version
+    def _maybe_quote(self, s: str) -> str:
+        if self._needs_quote(s):
+            return repr(s)
+        else:
+            return s
 
-    parts = []
+    #
 
-    if parsed.epoch != 0:
-        parts.append(f'{parsed.epoch}!')
+    def write_root(self, obj: ta.Mapping) -> None:
+        for i, (k, v) in enumerate(obj.items()):
+            if i:
+                self._nl()
+            self._w('[')
+            self._w(self._maybe_quote(k))
+            self._w(']')
+            self._nl()
+            self.write_table_contents(v)
 
-    release_segment = '.'.join(str(x) for x in parsed.release)
-    if strip_trailing_zero:
-        release_segment = re.sub(r'(\.0)+$', '', release_segment)
-    parts.append(release_segment)
+    def write_table_contents(self, obj: ta.Mapping) -> None:
+        for k, v in obj.items():
+            self.write_key(k)
+            self._w(' = ')
+            self.write_value(v)
+            self._nl()
 
-    if parsed.pre is not None:
-        parts.append(''.join(str(x) for x in parsed.pre))
+    def write_array(self, obj: ta.Sequence) -> None:
+        self._w('[')
+        self._nl()
+        self._indent += 1
+        for e in obj:
+            self.write_value(e)
+            self._w(',')
+            self._nl()
+        self._indent -= 1
+        self._w(']')
 
-    if parsed.post is not None:
-        parts.append(f'.post{parsed.post}')
+    def write_inline_table(self, obj: ta.Mapping) -> None:
+        self._w('{')
+        for i, (k, v) in enumerate(obj.items()):
+            if i:
+                self._w(', ')
+            self.write_key(k)
+            self._w(' = ')
+            self.write_value(v)
+        self._w('}')
 
-    if parsed.dev is not None:
-        parts.append(f'.dev{parsed.dev}')
+    def write_inline_array(self, obj: ta.Sequence) -> None:
+        self._w('[')
+        for i, e in enumerate(obj):
+            if i:
+                self._w(', ')
+            self.write_value(e)
+        self._w(']')
 
-    if parsed.local is not None:
-        parts.append(f'+{parsed.local}')
+    def write_key(self, obj: ta.Any) -> None:
+        if isinstance(obj, TomlWriter.Literal):
+            self._w(obj.s)
+        elif isinstance(obj, str):
+            self._w(self._maybe_quote(obj.replace('_', '-')))
+        elif isinstance(obj, int):
+            self._w(repr(str(obj)))
+        else:
+            raise TypeError(obj)
 
-    return ''.join(parts)
+    def write_value(self, obj: ta.Any) -> None:
+        if isinstance(obj, bool):
+            self._w(str(obj).lower())
+        elif isinstance(obj, (str, int, float)):
+            self._w(repr(obj))
+        elif isinstance(obj, ta.Mapping):
+            self.write_inline_table(obj)
+        elif isinstance(obj, ta.Sequence):
+            if not obj:
+                self.write_inline_array(obj)
+            else:
+                self.write_array(obj)
+        else:
+            raise TypeError(obj)
 
 
 ########################################
@@ -1899,6 +1899,11 @@ def check_non_empty_str(v: ta.Optional[str]) -> str:
     return v
 
 
+def check_state(v: bool, msg: str = 'Illegal state') -> None:
+    if not v:
+        raise ValueError(msg)
+
+
 ########################################
 # ../../../omlish/lite/json.py
 
@@ -2009,83 +2014,7 @@ def is_sunder(name: str) -> bool:
 
 
 ########################################
-# ../reqs.py
-"""
-TODO:
- - embed pip._internal.req.parse_requirements, add additional env stuff? breaks compat with raw pip
-"""
-
-
-class RequirementsRewriter:
-    def __init__(
-            self,
-            venv: ta.Optional[str] = None,
-    ) -> None:
-        super().__init__()
-        self._venv = venv
-
-    @cached_nullary
-    def _tmp_dir(self) -> str:
-        return tempfile.mkdtemp('-omlish-reqs')
-
-    VENV_MAGIC = '# @omlish-venv'
-
-    def rewrite_file(self, in_file: str) -> str:
-        with open(in_file) as f:
-            src = f.read()
-
-        in_lines = src.splitlines(keepends=True)
-        out_lines = []
-
-        for l in in_lines:
-            if self.VENV_MAGIC in l:
-                lp, _, rp = l.partition(self.VENV_MAGIC)
-                rp = rp.partition('#')[0]
-                omit = False
-                for v in rp.split():
-                    if v[0] == '!':
-                        if self._venv is not None and self._venv == v[1:]:
-                            omit = True
-                            break
-                    else:
-                        raise NotImplementedError
-
-                if omit:
-                    out_lines.append('# OMITTED:  ' + l)
-                    continue
-
-            out_req = self.rewrite(l.rstrip('\n'), for_file=True)
-            out_lines.append(out_req + '\n')
-
-        out_file = os.path.join(self._tmp_dir(), os.path.basename(in_file))
-        if os.path.exists(out_file):
-            raise Exception(f'file exists: {out_file}')
-
-        with open(out_file, 'w') as f:
-            f.write(''.join(out_lines))
-        return out_file
-
-    def rewrite(self, in_req: str, *, for_file: bool = False) -> str:
-        if in_req.strip().startswith('-r'):
-            l = in_req.strip()
-            lp, _, rp = l.partition(' ')
-            if lp == '-r':
-                inc_in_file, _, rest = rp.partition(' ')
-            else:
-                inc_in_file, rest = lp[2:], rp
-
-            inc_out_file = self.rewrite_file(inc_in_file)
-            if for_file:
-                return ' '.join(['-r ', inc_out_file, rest])
-            else:
-                return '-r' + inc_out_file
-
-        else:
-            return in_req
-
-
-########################################
-# ../../versioning/specifiers.py
+# ../../packaging/specifiers.py
 # Copyright (c) Donald Stufft and individual contributors.
 # All rights reserved.
 #
@@ -2606,6 +2535,82 @@ class SpecifierSet(BaseSpecifier):
             return iter(filtered)
 
 
+########################################
+# ../reqs.py
+"""
+TODO:
+ - embed pip._internal.req.parse_requirements, add additional env stuff? breaks compat with raw pip
+"""
+
+
+class RequirementsRewriter:
+    def __init__(
+            self,
+            venv: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+        self._venv = venv
+
+    @cached_nullary
+    def _tmp_dir(self) -> str:
+        return tempfile.mkdtemp('-omlish-reqs')
+
+    VENV_MAGIC = '# @omlish-venv'
+
+    def rewrite_file(self, in_file: str) -> str:
+        with open(in_file) as f:
+            src = f.read()
+
+        in_lines = src.splitlines(keepends=True)
+        out_lines = []
+
+        for l in in_lines:
+            if self.VENV_MAGIC in l:
+                lp, _, rp = l.partition(self.VENV_MAGIC)
+                rp = rp.partition('#')[0]
+                omit = False
+                for v in rp.split():
+                    if v[0] == '!':
+                        if self._venv is not None and self._venv == v[1:]:
+                            omit = True
+                            break
+                    else:
+                        raise NotImplementedError
+
+                if omit:
+                    out_lines.append('# OMITTED:  ' + l)
+                    continue
+
+            out_req = self.rewrite(l.rstrip('\n'), for_file=True)
+            out_lines.append(out_req + '\n')
+
+        out_file = os.path.join(self._tmp_dir(), os.path.basename(in_file))
+        if os.path.exists(out_file):
+            raise Exception(f'file exists: {out_file}')
+
+        with open(out_file, 'w') as f:
+            f.write(''.join(out_lines))
+        return out_file
+
+    def rewrite(self, in_req: str, *, for_file: bool = False) -> str:
+        if in_req.strip().startswith('-r'):
+            l = in_req.strip()
+            lp, _, rp = l.partition(' ')
+            if lp == '-r':
+                inc_in_file, _, rest = rp.partition(' ')
+            else:
+                inc_in_file, rest = lp[2:], rp
+
+            inc_out_file = self.rewrite_file(inc_in_file)
+            if for_file:
+                return ' '.join(['-r ', inc_out_file, rest])
+            else:
+                return '-r' + inc_out_file
+
+        else:
+            return in_req
+
+
 ########################################
 # ../../../omlish/lite/logs.py
 """