backrefs 5.8__tar.gz → 6.0__tar.gz

{backrefs-5.8 → backrefs-6.0}/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 - 2023 Isaac Muse
+Copyright (c) 2015 - 2025 Isaac Muse
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{backrefs-5.8 → backrefs-6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backrefs
-Version: 5.8
+Version: 6.0
 Summary: A wrapper around re and regex that adds additional back references.
 Project-URL: Homepage, https://github.com/facelessuser/backrefs
 Author-email: Isaac Muse <Isaac.Muse@gmail.com>
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
@@ -26,13 +27,12 @@ Requires-Dist: regex; extra == 'extras'
 Description-Content-Type: text/markdown
 
 [![Donate via PayPal][donate-image]][donate-link]
-[![Discord][discord-image]][discord-link]
 [![Build][github-ci-image]][github-ci-link]
 [![Coverage Status][codecov-image]][codecov-link]
 [![PyPI Version][pypi-image]][pypi-link]
 [![PyPI Downloads][pypi-down]][pypi-link]
 [![PyPI - Python Version][python-image]][pypi-link]
-![License][license-image-mit]
+[![License][license-image-mit]][license-link]
 
 # Backrefs
 
@@ -42,7 +42,7 @@ Python's Re and/or Regex.  The supported back references actually vary depending
 used as the engine may already have support for some.
 
 ```python
-from backrefs import bre
+>>> from backrefs import bre
 >>> pattern = bre.compile(r'(\p{Letter}+)')
 >>> pattern.sub(r'\C\1\E', 'sometext')
 'SOMETEXT'
@@ -56,10 +56,8 @@ https://facelessuser.github.io/backrefs/
 
 MIT
 
-[github-ci-image]: https://github.com/facelessuser/backrefs/workflows/build/badge.svg?branch=master&event=push
+[github-ci-image]: https://github.com/facelessuser/backrefs/workflows/build/badge.svg
 [github-ci-link]: https://github.com/facelessuser/backrefs/actions?query=workflow%3Abuild+branch%3Amaster
-[discord-image]: https://img.shields.io/discord/678289859768745989?logo=discord&logoColor=aaaaaa&color=mediumpurple&labelColor=333333
-[discord-link]:https://discord.gg/TWs8Tgr
 [codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/backrefs/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
 [codecov-link]: https://codecov.io/github/facelessuser/backrefs
 [pypi-image]: https://img.shields.io/pypi/v/backrefs.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
@@ -67,6 +65,7 @@ MIT
 [pypi-link]: https://pypi.python.org/pypi/backrefs
 [python-image]: https://img.shields.io/pypi/pyversions/backrefs?logo=python&logoColor=aaaaaa&labelColor=333333
 [license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
+[license-link]: https://github.com/facelessuser/backrefs/blob/main/LICENSE.md
 [donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
 [donate-link]: https://www.paypal.me/facelessuser
 

{backrefs-5.8 → backrefs-6.0}/README.md

@@ -1,11 +1,10 @@
 [![Donate via PayPal][donate-image]][donate-link]
-[![Discord][discord-image]][discord-link]
 [![Build][github-ci-image]][github-ci-link]
 [![Coverage Status][codecov-image]][codecov-link]
 [![PyPI Version][pypi-image]][pypi-link]
 [![PyPI Downloads][pypi-down]][pypi-link]
 [![PyPI - Python Version][python-image]][pypi-link]
-![License][license-image-mit]
+[![License][license-image-mit]][license-link]
 
 # Backrefs
 
@@ -15,7 +14,7 @@ Python's Re and/or Regex.  The supported back references actually vary depending
 used as the engine may already have support for some.
 
 ```python
-from backrefs import bre
+>>> from backrefs import bre
 >>> pattern = bre.compile(r'(\p{Letter}+)')
 >>> pattern.sub(r'\C\1\E', 'sometext')
 'SOMETEXT'
@@ -29,10 +28,8 @@ https://facelessuser.github.io/backrefs/
 
 MIT
 
-[github-ci-image]: https://github.com/facelessuser/backrefs/workflows/build/badge.svg?branch=master&event=push
+[github-ci-image]: https://github.com/facelessuser/backrefs/workflows/build/badge.svg
 [github-ci-link]: https://github.com/facelessuser/backrefs/actions?query=workflow%3Abuild+branch%3Amaster
-[discord-image]: https://img.shields.io/discord/678289859768745989?logo=discord&logoColor=aaaaaa&color=mediumpurple&labelColor=333333
-[discord-link]:https://discord.gg/TWs8Tgr
 [codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/backrefs/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
 [codecov-link]: https://codecov.io/github/facelessuser/backrefs
 [pypi-image]: https://img.shields.io/pypi/v/backrefs.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
@@ -40,6 +37,7 @@ MIT
 [pypi-link]: https://pypi.python.org/pypi/backrefs
 [python-image]: https://img.shields.io/pypi/pyversions/backrefs?logo=python&logoColor=aaaaaa&labelColor=333333
 [license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
+[license-link]: https://github.com/facelessuser/backrefs/blob/main/LICENSE.md
 [donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
 [donate-link]: https://www.paypal.me/facelessuser
 

{backrefs-5.8 → backrefs-6.0}/backrefs/__meta__.py

@@ -193,5 +193,5 @@ def parse_version(ver: str) -> Version:
     return Version(major, minor, micro, release, pre, post, dev)
 
 
-__version_info__ = Version(5, 8, 0, "final")
+__version_info__ = Version(6, 0, 0, "final")
 __version__ = __version_info__._get_canonical()

{backrefs-5.8 → backrefs-6.0}/backrefs/_bre_parse.py

@@ -37,11 +37,19 @@ _STANDARD_ESCAPES = frozenset(('a', 'b', 'f', 'n', 'r', 't', 'v'))
 _CURLY_BRACKETS = frozenset(('{', '}'))
 _PROPERTY_STRIP = frozenset((' ', '-', '_'))
 _PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP
-_GLOBAL_FLAGS = frozenset(('a', 'u', 'L'))
-_SCOPED_FLAGS = frozenset(('i', 'm', 's', 'u', 'x'))
+_GLOBAL_FLAGS = frozenset(('a', 'i', 'L', 'm', 's', 'u', 'x'))
+_SCOPED_FLAGS = frozenset(('i', 'm', 's', 'x'))
+_SCOPED_END = frozenset((':', ')'))
 
 _CURLY_BRACKETS_ORD = frozenset((0x7b, 0x7d))
 
+_COMPATIBILITY_PROPERTIES = frozenset(
+    (
+        'alpha', 'lower', 'upper', 'punct', 'digit', 'xdigit', 'alnum',
+        'space', 'blank', 'cntrl', 'graph', 'print', 'word'
+    )
+)
+
 # Case upper or lower
 _UPPER = 1
 _LOWER = 2
@@ -173,20 +181,24 @@ class _SearchParser(Generic[AnyStr]):
     def flags(self, text: str, scoped: bool = False) -> None:
         """Analyze flags."""
 
+        flags = text.split('-')
+        enable = flags[0]
+        disable = flags[1] if len(flags) > 1 else ''
+
         global_retry = False
-        if ('a' in text or 'L' in text) and self.unicode:
+        if ('a' in enable or 'L' in enable) and self.unicode:
             self.unicode = False
             if not scoped:
                 self.temp_global_flag_swap["unicode"] = True
                 global_retry = True
-        elif 'u' in text and not self.unicode and not self.is_bytes:
+        elif 'u' in enable and not self.unicode and not self.is_bytes:
             self.unicode = True
             if not scoped:
                 self.temp_global_flag_swap["unicode"] = True
                 global_retry = True
-        if '-x' in text and self.verbose:
+        if 'x' in disable and self.verbose:
             self.verbose = False
-        elif 'x' in text and not self.verbose:
+        elif 'x' in enable and not self.verbose:
             self.verbose = True
             if not scoped:
                 self.temp_global_flag_swap["verbose"] = True
@@ -253,7 +265,15 @@ class _SearchParser(Generic[AnyStr]):
             else:
                 raise SyntaxError(f"Missing or unmatched '{{' at {index}!") from e
 
-        return ''.join(prop).lower(), ''.join(value).lower()
+        p = ''.join(prop).lower()
+        v = ''.join(value).lower()
+
+        # Ensure when using POSIX form, that any property considered a compatibility property uses the POSIX form.
+        # POSIX form is not guaranteed to be different from standard form and sometimes is just an alias for standard.
+        if brackets and p in _COMPATIBILITY_PROPERTIES:
+            p = 'posix' + p
+
+        return p, v
 
     def get_named_unicode(self, i: _util.StringIter) -> str:
         """Get Unicode name."""
@@ -345,51 +365,56 @@ class _SearchParser(Generic[AnyStr]):
 
         return ''.join(value)
 
-    def get_flags(self, i: _util.StringIter, scoped: bool = False) -> str | None:
-        """Get flags."""
+    def get_flags(self, i: _util.StringIter) -> tuple[str | None, bool]:
+        """
+        Get flags.
+
+        In Re, flags are quite predictable when global or scoped.
+        Global can never be disabled with minus, and never have a `:` after them.
+        The global flag set is also very specific, but can be used as enablers in scoped.
+
+        The returned scoped status will indicate whether flags are generally considered
+        scoped flags or global flags.
+        """
 
         index = i.index
         value = ['(']
         toggle = False
-        end = ':' if scoped else ')'
+        smells_scoped = False
         try:
             c = next(i)
             if c != '?':
                 i.rewind(1)
-                return None
+                return None, False
             value.append(c)
             c = next(i)
-            while c != end:
+            while c not in _SCOPED_END:
                 if toggle:
                     if c not in _SCOPED_FLAGS:
                         raise ValueError('Bad scope')
-                    toggle = False
-                elif scoped and c == '-':
+                elif c == '-':
+                    smells_scoped = True
                     toggle = True
-                elif scoped and c in _GLOBAL_FLAGS:
-                    raise ValueError("Bad flag")
-                elif c not in _GLOBAL_FLAGS and c not in _SCOPED_FLAGS:
+                elif c not in _GLOBAL_FLAGS:
                     raise ValueError("Bad flag")
                 value.append(c)
                 c = next(i)
+            if smells_scoped and c != ':':
+                raise ValueError("Bad flag")
+            elif c == ':':
+                smells_scoped = True
             value.append(c)
         except Exception:
             i.rewind(i.index - index)
             value = []
 
-        return ''.join(value) if value else None
+        return ''.join(value) if value else None, smells_scoped
 
     def subgroup(self, t: str, i: _util.StringIter) -> list[str]:
         """Handle parenthesis."""
 
         current = []  # type: list[str]
 
-        # (?flags)
-        flags = self.get_flags(i)
-        if flags:
-            self.flags(flags[2:-1])
-            return [flags]
-
         # (?#comment)
         comments = self.get_comments(i)
         if comments:
@@ -398,11 +423,13 @@ class _SearchParser(Generic[AnyStr]):
         verbose = self.verbose
         unicode_flag = self.unicode
 
-        # (?flags:pattern)
-        flags = self.get_flags(i, True)
+        # (?flags:pattern) or (?flags)
+        flags, scoped = self.get_flags(i)
         if flags:  # pragma: no cover
             t = flags
-            self.flags(flags[2:-1], scoped=True)
+            self.flags(flags[2:-1], scoped=scoped)
+            if not scoped:
+                return [flags]
 
         current = []
         try:

{backrefs-5.8 → backrefs-6.0}/backrefs/_bregex_parse.py

@@ -30,9 +30,10 @@ _STANDARD_ESCAPES = frozenset(('a', 'b', 'f', 'n', 'r', 't', 'v'))
 _CURLY_BRACKETS = frozenset(('{', '}'))
 _PROPERTY_STRIP = frozenset((' ', '-', '_'))
 _PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP
-_GLOBAL_FLAGS = frozenset(('L', 'a', 'b', 'e', 'r', 'u', 'p'))
-_SCOPED_FLAGS = frozenset(('i', 'm', 's', 'f', 'w', 'x'))
+_GLOBAL_FLAGS = frozenset(('b', 'e', 'p', 'r', 'u'))
+_SCOPED_FLAGS = frozenset(('a', 'f', 'i', 'L', 'm', 's', 'u', 'w', 'x'))
 _VERSIONS = frozenset(('0', '1'))
+_SCOPED_END = frozenset((':', ')'))
 
 _CURLY_BRACKETS_ORD = frozenset((0x7b, 0x7d))
 
@@ -163,21 +164,25 @@ class _SearchParser(Generic[AnyStr]):
     def flags(self, text: str, scoped: bool = False) -> None:
         """Analyze flags."""
 
+        flags = text.split('-')
+        enable = flags[0]
+        disable = flags[1] if len(flags) > 1 else ''
+
         global_retry = False
-        if (self.version == _regex.V1 or scoped) and '-x' in text and self.verbose:
+        if (self.version == _regex.V1 or scoped) and 'x' in disable and self.verbose:
             self.verbose = False
-        elif 'x' in text and not self.verbose:
+        elif 'x' in enable and not self.verbose:
             self.verbose = True
             if not scoped and self.version == _regex.V0:
                 self.temp_global_flag_swap['verbose'] = True
                 global_retry = True
-        if 'V0' in text and self.version == _regex.V1:  # pragma: no cover
+        if 'V0' in enable and self.version == _regex.V1:  # pragma: no cover
             # Default is V0 if none is selected,
             # so it is unlikely that this will be selected.
             self.temp_global_flag_swap['version'] = True
             self.version = _regex.V0
             global_retry = True
-        elif "V1" in text and self.version == _regex.V0:
+        elif "V1" in enable and self.version == _regex.V0:
             self.temp_global_flag_swap['version'] = True
             self.version = _regex.V1
             global_retry = True
@@ -260,54 +265,61 @@ class _SearchParser(Generic[AnyStr]):
 
         return ''.join(value) if value else None
 
-    def get_flags(self, i: _util.StringIter, version0: bool, scoped: bool = False) -> str | None:
-        """Get flags."""
+    def get_flags(self, i: _util.StringIter) -> tuple[str | None, bool]:
+        """
+        Get flags.
+
+        Regex is more difficult to determine when flags are used in a global and scoped context.
+        There is a specific list of global flags, but they can be used in scoped notation and will still
+        be considered global, but that does not mean other flags are global. Additionally, flags that can be
+        scoped can also used be used in global syntax, but can be disabled with a minus unlike in RE.
+
+        Bregex only cares about capturing the "verbose" flag and the version flags. Version flags are always
+        global and verbose flags will be scoped based on whether they are in a scoped group. The returned
+        "scoped" parameter only refers to "verbose".
+        """
 
         index = i.index
         value = ['(']
         version = False
         toggle = False
-        end = ':' if scoped else ')'
+        smells_scoped = False
         try:
             c = next(i)
             if c != '?':
                 i.rewind(1)
-                return None
+                return None, False
             value.append(c)
             c = next(i)
-            while c != end:
+            while c not in _SCOPED_END:
                 if toggle:
                     if c not in _SCOPED_FLAGS:
                         raise ValueError('Bad scope')
-                    toggle = False
-                elif (not version0 or scoped) and c == '-':
-                    toggle = True
                 elif version:
                     if c not in _VERSIONS:
                         raise ValueError('Bad version')
                     version = False
+                elif c == '-':
+                    toggle = True
                 elif c == 'V':
                     version = True
                 elif c not in _GLOBAL_FLAGS and c not in _SCOPED_FLAGS:
                     raise ValueError("Bad flag")
                 value.append(c)
                 c = next(i)
+            if c == ':':
+                smells_scoped = True
+
             value.append(c)
         except Exception:
             i.rewind(i.index - index)
             value = []
 
-        return ''.join(value) if value else None
+        return ''.join(value) if value else None, smells_scoped
 
     def subgroup(self, t: str, i: _util.StringIter) -> list[str]:
         """Handle parenthesis."""
 
-        # (?flags)
-        flags = self.get_flags(i, self.version == _regex.V0)
-        if flags:
-            self.flags(flags[2:-1])
-            return [flags]
-
         # (?#comment)
         comments = self.get_comments(i)
         if comments:
@@ -315,11 +327,14 @@ class _SearchParser(Generic[AnyStr]):
 
         verbose = self.verbose
 
-        # (?flags:pattern)
-        flags = self.get_flags(i, (self.version == _regex.V0), True)
+        # (?flags:pattern) or (?flags)
+        # "scoped" only refers to verbose
+        flags, scoped = self.get_flags(i)
         if flags:
             t = flags
-            self.flags(flags[2:-1], scoped=True)
+            self.flags(flags[2:-1], scoped=scoped)
+            if not scoped:
+                return [flags]
 
         current = []  # type: list[str]
         try:

{backrefs-5.8 → backrefs-6.0}/docs/src/markdown/about/changelog.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 6.0
+
+-   **NEW**: POSIX character classes will now always use POSIX compatibility rules instead of Unicode standard rules,
+    if any are specified in the Unicode specification. The affected character classes are: `[[:alnum:]]`, `[[:digit:]]`,
+    `[[:xdigit:]]`, and  `[[:punct:]]`. To explicitly use standard Unicode rules for these compatibility properties, use
+    the Unicode property form instead: `[\p{Alnum}]`, `[\p{Digit}]`, `[\p{Punct}]`, or `[\p{XDigit}]`. This has changed
+    to ensure no confusion for users expecting compatible POSIX style character class properties.
+-   **FIX**: Scoped ASCII/Unicode flags (`(?a:pattern)`/`(?u:pattern)`) should be respected for Unicode properties in
+    `bre` and will ensure ASCII or Unicode range if used.
+-   **FIX**: Fix issues related to detecting disabled scoped flags.
+
+## 5.9
+
+-   **NEW**: Add support for Python 3.14.
+-   **ENHANCE**: Switch to deploying with PyPI's "Trusted Publisher".
+
 ## 5.8
 
 -   **NEW**: Drop Python 3.8.
@@ -23,8 +39,8 @@
 
 ## 5.5
 
--   **NEW**: `\e` and `\h` have both been deprecated in 6.0. Please migrate to using `\x1b` and `\p{Horiz_Space}` in
-    their respective place.
+-   **NEW**: `\e` and `\h` have both been deprecated. Please migrate to using `\x1b` and `\p{Horiz_Space}` in their
+    respective place.
 -   **FIX**: Fix flag issue with `sub` functions.
 
 ## 5.4

{backrefs-5.8 → backrefs-6.0}/docs/src/markdown/refs.md

@@ -199,12 +199,12 @@ Block properties have a similar short form as Script and Binary properties.  For
 a block. If we wanted to match characters in the `Basic_Latin` block, we could use the syntax `\p{InBasic_Latin}`. This
 would be the same as `\p{Block: Basic_Latin}` or `\p{Basic_Latin}`.
 
-/// warn | Short Name Conflicts
+/// warning | Short Name Conflicts
 When it comes to short names, each new Unicode version, there is a risk that new properties could cause conflicts
 with existing names and/or aliases. Currently, most of the conflicts involve the Block properties. To reduce
 friction, they are evaluated last.
 
-Generally, it is discouraged to use short names for Block properties. But the option is still supported, but Block 
+Generally, it is discouraged to use short names for Block properties. But the option is still supported, but Block
 properties will be evaluated last. There are currently no known conflicts with `In*` properties, but in future
 Unicode versions there could.
 
@@ -259,67 +259,18 @@ Verbose\ Property\ Form            | Terse\ Property\ Form
  `Line_Separator`                  | `Zl`
  `Paragraph_Separator`             | `Z`
 
-### POSIX Style Properties
-
-/// new | New in 5.0
-5.0 brings significant improvements and bug fixes to Unicode property handling. Properties are sensitive to the
-`ASCII` flag along with more extensive testing and bug fixes. Additionally, POSIX style properties are now just
-an extension of normal Unicode properties. All the POSIX names are available and now conform to
-the [Unicode specification for POSIX compatibility](https://unicode.org/reports/tr18/#Compatibility_Properties).
-Read on to learn more.
-///
-
-Backrefs allows for POSIX style properties in the form `[:name:]`. These properties can only be used inside character
-classes and are another form for expressing Unicode properties. Any Unicode property that can be expressed via the
-`\p{name}` form can also be expressed in the `[:name:]` form. To illustrate, the following are all the same:
-
--   `[[:upper:]]` == `[\p{upper}]`
--   `[[:^upper:]]` == `[\p{^upper}]`
--   `[[:alpha=yes:]]` == `[\p{alpha=yes}]`
-
-A number of POSIX property names are available via compatibility properties as outlined in the
-[Unicode specification for POSIX compatibility](https://unicode.org/reports/tr18/#Compatibility_Properties). These
-properties will operate in the Unicode range and the ASCII range depending on the regular expression mode. These
-patterns, like all Unicode properties, are sensitive to the `ASCII` flag (or `LOCALE` which will treat them as `ASCII`).
-
-It is important to note that whether used in the form `[[:name:]]` or `\p{name}`, each POSIX name is available both with
-and without the `posix` prefix, but it is recommended to use the `posix` prefix to get the POSIX definition of the
-pattern as number of patterns have both a POSIX and Unicode definition that differ. The
-[Unicode specification for POSIX compatibility](https://unicode.org/reports/tr18/#Compatibility_Properties) outlines all
-the POSIX compatible properties and the ones which have dual definitions: `punct`, `alnum`, `digit`, and `xdigit` all
-have a Unicode standard and a POSIX compatibility variant and must be accessed with the `posix` prefix to get the POSIX
-form.
-
-In the table below, patterns with `--` mean `[[in this] -- [but not this]]`.
-
-\[:posix:] | \\p\{Posix}   | ASCII                                             | Unicode
----------- | ------------- | ------------------------------------------------- | -------
-`alpha`    | `Alpha`       | `[a-zA-Z]`                                        | `\p{Alphabetic}`
-`alnum`    | `PosixAlnum`  | `[[:alpha:][:digit:]]`                            | `[[:alpha:][:digit:]]`
-`blank`    | `Blank`       | `[ \t]`                                           | `[\p{Zs}\t]`
-`cntrl`    | `Cntrl`       | `[\x00-\x1F\x7F]`                                 | `\p{Cc}`
-`digit`    | `PosixDigit`  | `[0-9]`                                           | `[0-9]`
-`graph`    | `Graph`       | `[^ [:cntrl:]]`                                   | `[^[:space:][:cntrl:]\p{Cn}\p{Cs}]`
-`lower`    | `Lower`       | `[a-z]`                                           | `[\p{Lowercase}]`
-`print`    | `Print`       | `[[:graph:] ]`                                    | `[[\p{P}\p{S}]--[\p{alpha}]]`
-`punct`    | `PosixPunct`  | ``[!\"\#$%&'()*+,\-./:;<=>?@\[\\\]^_`{}~]`` | `[[[:graph:][:blank:]]--[[:cntrl:]]]`
-`space`    | `Space`       | `[ \t\r\n\v\f]`                                   | `[\p{Whitespace}]`
-`upper`    | `Upper`       | `[A-Z]`                                           | `[\p{Uppercase}]`
-`xdigit`   | `PosixXDigit` | `[A-Fa-f0-9]`                                     | `[A-Fa-f0-9]`
-
 ### Compatibility Properties
 
 /// new | New in 5.0
 While many of the properties were available before 5.0, `word` is newly available. And all the properties now
-conform to the [Unicode specification for POSIX compatibility](https://unicode.org/reports/tr18/#Compatibility_Properties).
+conform to the [Unicode specification for compatibility properties](https://unicode.org/reports/tr18/#Compatibility_Properties).
 ///
 
-[Unicode specification for POSIX compatibility][unicode-posix] defines a number of properties, many of which double as
-[Posix properties](#posix-style-properties). These properties can be accessed via `\p{name}` or `[[:name:]]`.
-
-In the table below, patterns with `--` mean `[[in this] -- [but not this]]`.
+[Unicode specification for compatibility properties][unicode-posix] defines a number of properties for use in regular
+expressions. The table below shows the names of these properties along with their standard rules as implemented in
+Backrefs. Patterns with `--` mean `[[in this] -- [but not this]]`.
 
-\\p\{Posix}   | Unicode
+\\p\{name}    | Unicode
 ------------- | -------
 `Alpha`       | `\p{Alphabetic}`
 `Alnum`       | `[\p{Alpha}\p{Digit}]`
@@ -328,9 +279,84 @@ In the table below, patterns with `--` mean `[[in this] -- [but not this]]`.
 `Digit`       | `\p{Nd}`
 `Graph`       | `[^\p{Space}\p{Cntrl}\p{Cn}\p{Cs}]`
 `Lower`       | `\p{Lowercase}`
-`Print`       | `[[\p{P}\p{S}]--[\p{Alpha}]]`
+`Print`       | `[\p{graph}\p{blank}--\p{cntrl}]`
 `Punct`       | `\p{P}`
 `Space`       | `\p{Whitespace}`
 `Upper`       | `\p{Uppercase}`
 `Word`        | `[\p{Alnum}\p{M}\p{Pc}\p{JoinControl}]`
 `XDigit`      | `[\p{Nd}\p{HexDigit}]`
+
+The [Unicode specification for compatibility properties](https://unicode.org/reports/tr18/#Compatibility_Properties)
+also defines rules for POSIX compatibility which provides modifications to the standard recommendation required to meet
+the formal requirements of POSIX, and also to maintain (as much as possible) compatibility with the POSIX usage in
+practice.
+
+To accommodate these POSIX compatible rules, Backrefs defines POSIX property names for all the compatibility properties.
+For any that do not have special accommodations, the POSIX property name will act as an alias for the standard Unicode
+name. In all, four properties are specifically affected with POSIX specific accommodations: `Alnum`, `Digit`, `Punct`,
+and `XDigit`.
+
+\\p\{name}    | Unicode
+------------- | -------
+`PosixAlpha`  | `\p{Alpha}`
+`PosixAlnum`  | `[\p{Alpha}\p{PosixDigit}]`
+`PosixBlank`  | `\p{Blank}`
+`PosixCntrl`  | `\p{Cntrl}`
+`PosixDigit`  | `[0-9]`
+`PosixGraph`  | `\p{Graph}`
+`PosixLower`  | `\p{Lower}`
+`PosixPrint`  | `\p{Print}`
+`PosixPunct`  | `[[\p{P}\p{S}]--[\p{alpha}]]`
+`PosixSpace`  | `\p{Space}`
+`PosixUpper`  | `\p{Uppper}`
+`PosixWord`   | `\p{Word}`
+`PosixXDigit` | `[A-Fa-f0-9]`
+
+### POSIX Character Classes
+
+/// new | New in 6.0
+POSIX character classes in the form of `[:name:]` are now forced to always use POSIX compatible rules if available.
+These rules are defined in the [Unicode specification for compatibility properties]
+(https://unicode.org/reports/tr18/#Compatibility_Properties).
+///
+
+Backrefs allows for POSIX style character classes in the form of `[:name:]`. These properties can only be used inside
+character classes, e.g. `[[:name:]]`.
+
+When using POSIX character classes, all character classes will use the matching rules as stated in the
+[Unicode specification for compatibility properties](https://unicode.org/reports/tr18/#Compatibility_Properties). If
+there are specific rules for POSIX compatibility, those will be used in the bracket expression instead of the Unicode
+standard form. For all others, the Unicode standard form will be used.
+
+The table below outlines the supported POSIX names that can be used in the form `[:name:]` and details the differences
+in rules if using ASCII mode or Unicode mode.
+
+\[:posix:] | ASCII                                                         | Unicode
+---------- | ------------------------------------------------------------- | -------
+`alpha`    | `[a-zA-Z]`                                                    | `\p{Alphabetic}`
+`alnum`    | `[[:alpha:][:digit:]]`                                        | `[[:alpha:][:digit:]]`
+`blank`    | `[ \t]`                                                       | `[\p{Zs}\t]`
+`cntrl`    | `[\x00-\x1F\x7F]`                                             | `\p{Cc}`
+`digit`    | `[0-9]`                                                       | `[0-9]`
+`graph`    | `[^ [:cntrl:]]`                                               | `[^[:space:][:cntrl:]\p{Cn}\p{Cs}]`
+`lower`    | `[a-z]`                                                       | `[\p{Lowercase}]`
+`print`    | `[[:graph:] ]`                                                | `[[[:graph:][:blank:]]--[[:cntrl:]]]`
+`punct`    | ``[!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~]``                       | `[[\p{P}\p{S}]--[\p{alpha}]]`
+`space`    | `[ \t\r\n\v\f]`                                   			   | `[\p{Whitespace}]`
+`upper`    | `[A-Z]`                                           			   | `[\p{Uppercase}]`
+`word`     | `[A-Za-z0-9_]`												   | `[\p{Alnum}\p{M}\p{Pc}\p{JoinControl}]`
+`xdigit`   | `[A-Fa-f0-9]`                                     			   | `[A-Fa-f0-9]`
+
+/// Tip
+Using POSIX character classes is equivalent to using Unicode compatibility properties for POSIX, e.g. `[[:punct:]]`
+== `\p{Posix Punct}`.
+///
+
+POSIX style character classes have also been extended to allow for specifying normal Unicode properties as well. Any
+Unicode property, outside the compatibility properties, will be accepted in the bracket extension form and behave just
+like normal Unicode properties. To illustrate, the following are equivalent:
+
+-   `[[:math:]]` == `[\p{math}]`
+-   `[[:scx=latin:]]` == `[\p{scx: latin}]`
+-   `[[:^scx=latin:]]` == `[\P{scx: latin}]`
+

{backrefs-5.8 → backrefs-6.0}/hatch_build.py

@@ -79,6 +79,7 @@ class CustomMetadataHook(MetadataHookInterface):
             'Programming Language :: Python :: 3.11',
             'Programming Language :: Python :: 3.12',
             'Programming Language :: Python :: 3.13',
+            'Programming Language :: Python :: 3.14',
             'Topic :: Software Development :: Libraries :: Python Modules',
             'Typing :: Typed'
         ]

{backrefs-5.8 → backrefs-6.0}/mkdocs.yml

@@ -4,7 +4,7 @@ repo_url: https://github.com/facelessuser/backrefs
 edit_uri: tree/master/docs/src/markdown
 site_description: A library to add additional back references to regular expressions.
 copyright: |
-  Copyright &copy; 2015 - 2023 <a href="https://github.com/facelessuser"  target="_blank" rel="noopener">Isaac Muse</a>
+  Copyright &copy; 2015 - 2025 <a href="https://github.com/facelessuser"  target="_blank" rel="noopener">Isaac Muse</a>
 
 docs_dir: docs/src/markdown
 theme:
@@ -152,8 +152,6 @@ extra:
   social:
     - icon: fontawesome/brands/github
       link: https://github.com/facelessuser
-    - icon: fontawesome/brands/discord
-      link: https://discord.gg/TWs8Tgr
 
 plugins:
   - search

{backrefs-5.8 → backrefs-6.0}/pyproject.toml

@@ -135,7 +135,7 @@ legacy_tox_ini = """
 [tox]
 isolated_build = true
 envlist =
-    py39,py310,py311,py312,py313,
+    py39,py310,py311,py312,py313,py314,
     lint
 
 [testenv]
@@ -157,7 +157,7 @@ passenv = *
 deps=
     -r requirements/docs.txt
 commands=
-    {envpython} -m mkdocs build --clean --verbose --strict
+    {envbindir}/mkdocs build --clean --verbose --strict
     {envbindir}/pyspelling
 
 [testenv:lint]

{backrefs-5.8 → backrefs-6.0}/tests/test_bre.py

@@ -11,6 +11,7 @@ import copy
 
 PY39_PLUS = (3, 9) <= sys.version_info
 PY311_PLUS = (3, 11) <= sys.version_info
+PY313_PLUS = (3, 13) <= sys.version_info
 
 if PY311_PLUS:
     import re._constants as _constants
@@ -21,6 +22,20 @@ else:
 class TestSearchTemplate(unittest.TestCase):
     """Search template tests."""
 
+    def test_multi_disable_flag(self):
+        """Test when multiple flags are disabled."""
+
+        self.assertTrue(bre.match(r'(?-ix:Test Test)', 'Test Test', flags=bre.IGNORECASE | bre.VERBOSE))
+        self.assertTrue(bre.match(r'(?s-ix:Test Test)', 'Test Test', flags=bre.IGNORECASE | bre.VERBOSE))
+
+    def test_inline_unicode(self):
+        """Test inline Unicode/ASCII cases."""
+
+        self.assertTrue(bre.match(r'\p{N}', '\uff19', flags=bre.ASCII) is None)
+        self.assertTrue(bre.match(r'(?u:\p{N})', '\uff19', flags=bre.ASCII) is not None)
+        self.assertTrue(bre.match(r'\p{N}', '\uff19', flags=bre.UNICODE) is not None)
+        self.assertTrue(bre.match(r'(?a:\p{N})', '\uff19', flags=bre.UNICODE) is None)
+
     def test_custom_binary_properties(self):
         """Test new custom binary properties."""
 
@@ -1986,6 +2001,16 @@ class TestReplaceTemplate(unittest.TestCase):
 class TestExceptions(unittest.TestCase):
     """Test Exceptions."""
 
+    def test_bad_flag(self):
+        """Test bad flag."""
+
+        if PY313_PLUS:
+            with self.assertRaises(re.PatternError):
+                bre.compile(r'(?-i)')
+        else:
+            with self.assertRaises(re.error):
+                bre.compile(r'(?-i)')
+
     def test_format_existing_group_no_match_with_index(self):
         """Test format group with no match and attempt at indexing."""
 

{backrefs-5.8 → backrefs-6.0}/tests/test_bregex.py

@@ -20,6 +20,12 @@ PY39_PLUS = (3, 9) <= sys.version_info
 class TestSearchTemplate(unittest.TestCase):
     """Search template tests."""
 
+    def test_multi_disable_flag(self):
+        """Test when multiple flags are disabled."""
+
+        self.assertTrue(bregex.match(r'(?-ix:Test Test)', 'Test Test', flags=bregex.IGNORECASE | bregex.VERBOSE))
+        self.assertTrue(bregex.match(r'(?s-ix:Test Test)', 'Test Test', flags=bregex.IGNORECASE | bregex.VERBOSE))
+
     def test_named_lists_attribute(self):
         """Test named list attribute."""
 

{backrefs-5.8 → backrefs-6.0}/tools/unipropgen.py

@@ -1,7 +1,6 @@
 """Generate a Unicode prop table for Python builds."""
 import sys
 import unicodedata
-import codecs
 import os
 import re
 
@@ -201,7 +200,7 @@ def discover_categories():
 
     # NF Quick Check categories
     file_name = os.path.join(HOME, 'unicodedata', UNIVERSION, 'DerivedNormalizationProps.txt')
-    with codecs.open(file_name, 'r', 'utf-8') as uf:
+    with open(file_name, 'r', encoding='utf-8') as uf:
         for line in uf:
             if not line.startswith('#'):
                 data = line.split('#')[0].split(';')
@@ -227,7 +226,7 @@ def discover_categories():
         binary_props.append(('emoji-data.txt', None))
 
     for filename, include in binary_props:
-        with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, filename), 'r', 'utf-8') as uf:
+        with open(os.path.join(HOME, 'unicodedata', UNIVERSION, filename), 'r', encoding='utf-8') as uf:
             for line in uf:
                 if not line.startswith('#'):
                     data = line.split('#')[0].split(';')
@@ -245,7 +244,7 @@ def discover_categories():
 def gen_blocks(output, ascii_props=False, append=False, prefix="", aliases=None):
     """Generate Unicode blocks."""
 
-    with codecs.open(output, 'a' if append else 'w', 'utf-8') as f:
+    with open(output, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         f.write('%s_blocks: dict[str, str] = {' % prefix)
@@ -257,7 +256,7 @@ def gen_blocks(output, ascii_props=False, append=False, prefix="", aliases=None)
         max_range = MAXUNICODE
         formatter = uniformat
 
-        with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'Blocks.txt'), 'r', 'utf-8') as uf:
+        with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'Blocks.txt'), 'r', encoding='utf-8') as uf:
             for line in uf:
                 if not line.startswith('#'):
                     data = line.split(';')
@@ -321,7 +320,7 @@ def gen_ccc(output, ascii_props=False, append=False, prefix="", aliases=None):
         for v in aliases.get('canonicalcombiningclass', {}).values():
             obj[v] = []
 
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'DerivedCombiningClass.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'DerivedCombiningClass.txt'), 'r', encoding='utf-8') as uf:
         for line in uf:
             if not line.startswith('#'):
                 data = line.split('#')[0].split(';')
@@ -350,7 +349,7 @@ def gen_ccc(output, ascii_props=False, append=False, prefix="", aliases=None):
     # Convert characters values to ranges
     char2range(obj, is_bytes=ascii_props)
 
-    with codecs.open(output, 'a' if append else 'w', 'utf-8') as f:
+    with open(output, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         # Write out the Unicode properties
@@ -382,13 +381,13 @@ def gen_scripts(
             obj2[v] = []
 
     alias = {}
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'PropertyValueAliases.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'PropertyValueAliases.txt'), 'r', encoding='utf-8') as uf:
         for line in uf:
             if line.startswith('sc ;'):
                 values = line.split(';')
                 alias[format_name(values[1].strip())] = format_name(values[2].strip())
 
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, file_name_ext), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, file_name_ext), 'r', encoding='utf-8') as uf:
         for line in uf:
             if not line.startswith('#'):
                 data = line.split('#')[0].split(';')
@@ -404,7 +403,7 @@ def gen_scripts(
 
                     obj2[ext].extend(span)
 
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, file_name), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, file_name), 'r', encoding='utf-8') as uf:
         for line in uf:
             if not line.startswith('#'):
                 data = line.split('#')[0].split(';')
@@ -439,7 +438,7 @@ def gen_scripts(
     char2range(obj, is_bytes=ascii_props)
     char2range(obj2, is_bytes=ascii_props)
 
-    with codecs.open(output, 'a' if append else 'w', 'utf-8') as f:
+    with open(output, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         # Write out the Unicode properties
@@ -454,7 +453,7 @@ def gen_scripts(
                 f.write(',\n')
             i += 1
 
-    with codecs.open(output_ext, 'a' if append else 'w', 'utf-8') as f:
+    with open(output_ext, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         # Write out the Unicode properties
@@ -482,7 +481,7 @@ def gen_enum(
         for v in aliases.get(format_name(obj_name), {}).values():
             obj[v] = []
 
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, file_name), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, file_name), 'r', encoding='utf-8') as uf:
         for line in uf:
             if not line.startswith('#'):
                 data = line.split('#')[0].split(';')
@@ -508,7 +507,7 @@ def gen_enum(
     # Convert characters values to ranges
     char2range(obj, is_bytes=ascii_props)
 
-    with codecs.open(output, 'a' if append else 'w', 'utf-8') as f:
+    with open(output, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         # Write out the Unicode properties
@@ -535,7 +534,7 @@ def gen_age(output, ascii_props=False, append=False, prefix="", aliases=None):
             obj[v] = []
 
     all_chars = (ALL_CHARS - ASCII_UNUSED) if ascii_props else ALL_CHARS
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'DerivedAge.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'DerivedAge.txt'), 'r', encoding='utf-8') as uf:
         for line in uf:
             if not line.startswith('#'):
                 data = line.split('#')[0].split(';')
@@ -564,7 +563,7 @@ def gen_age(output, ascii_props=False, append=False, prefix="", aliases=None):
     # Convert characters values to ranges
     char2range(obj, is_bytes=ascii_props)
 
-    with codecs.open(output, 'a' if append else 'w', 'utf-8') as f:
+    with open(output, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         # Write out the Unicode properties
@@ -586,7 +585,7 @@ def gen_nf_quick_check(output, ascii_props=False, append=False, prefix="", alias
     nf = {}
     all_chars = (ALL_CHARS - ASCII_UNUSED) if ascii_props else ALL_CHARS
     file_name = os.path.join(HOME, 'unicodedata', UNIVERSION, 'DerivedNormalizationProps.txt')
-    with codecs.open(file_name, 'r', 'utf-8') as uf:
+    with open(file_name, 'r', encoding='utf-8') as uf:
         for line in uf:
             if not line.startswith('#'):
                 data = line.split('#')[0].split(';')
@@ -626,7 +625,7 @@ def gen_nf_quick_check(output, ascii_props=False, append=False, prefix="", alias
     # Convert characters values to ranges
     char2range(nf, is_bytes=ascii_props)
 
-    with codecs.open(output, 'a' if append else 'w', 'utf-8') as f:
+    with open(output, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         for key, value in sorted(nf.items()):
@@ -670,7 +669,7 @@ def gen_binary(table, output, ascii_props=False, append=False, prefix="", aliase
     binary['vertspace'] = [x for x in binary['vertspace'] if x <= max_range]
 
     for filename, include in binary_props:
-        with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, filename), 'r', 'utf-8') as uf:
+        with open(os.path.join(HOME, 'unicodedata', UNIVERSION, filename), 'r', encoding='utf-8') as uf:
             for line in uf:
                 if not line.startswith('#'):
                     data = line.split('#')[0].split(';')
@@ -687,7 +686,7 @@ def gen_binary(table, output, ascii_props=False, append=False, prefix="", aliase
                         continue
                     binary[name].extend(span)
 
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'CompositionExclusions.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'CompositionExclusions.txt'), 'r', encoding='utf-8') as uf:
         name = 'compositionexclusion'
         for line in uf:
             if not line.startswith('#'):
@@ -703,7 +702,7 @@ def gen_binary(table, output, ascii_props=False, append=False, prefix="", aliase
                 binary[name].extend(span)
 
     file_name = os.path.join(HOME, 'unicodedata', UNIVERSION, 'DerivedNormalizationProps.txt')
-    with codecs.open(file_name, 'r', 'utf-8') as uf:
+    with open(file_name, 'r', encoding='utf-8') as uf:
         name = "fullcompositionexclusion"
         for line in uf:
             if not line.startswith('#'):
@@ -720,7 +719,7 @@ def gen_binary(table, output, ascii_props=False, append=False, prefix="", aliase
                     binary[name] = []
                 binary[name].extend(span)
 
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'UnicodeData.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'UnicodeData.txt'), 'r', encoding='utf-8') as uf:
         name = 'bidimirrored'
         for line in uf:
             data = line.strip().split(';')
@@ -741,16 +740,6 @@ def gen_binary(table, output, ascii_props=False, append=False, prefix="", aliase
 
     gen_uposix(table, binary, ascii_props)
 
-    # One off Unicode property found under https://unicode.org/reports/tr18/#Compatibility_Properties
-    # `Word: [\p{alnum}\p{M}\p{Pc}\p{JoinControl}]`
-    s = set(binary["alnum"])
-    for k, v in table['m'].items():
-        if not k.startswith('^'):
-            s |= set(v)
-    s |= set(table["p"]["c"])
-    s |= set(binary["joincontrol"])
-    binary["word"] = list(s)
-
     if aliases:
         for v in aliases.get('binary', {}).values():
             if v not in binary and '^' + v not in binary:
@@ -759,7 +748,7 @@ def gen_binary(table, output, ascii_props=False, append=False, prefix="", aliase
     # Convert characters values to ranges
     char2range(binary, is_bytes=ascii_props)
 
-    with codecs.open(output, 'a' if append else 'w', 'utf-8') as f:
+    with open(output, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         # Write out the Unicode properties
@@ -786,7 +775,7 @@ def gen_bidi(output, ascii_props=False, append=False, prefix="", aliases=None):
             bidi_class[v] = []
 
     max_range = MAXVALIDASCII if ascii_props else MAXUNICODE
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'UnicodeData.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'UnicodeData.txt'), 'r', encoding='utf-8') as uf:
         for line in uf:
             data = line.strip().split(';')
             if data:
@@ -810,7 +799,7 @@ def gen_bidi(output, ascii_props=False, append=False, prefix="", aliases=None):
     # Convert characters values to ranges
     char2range(bidi_class, is_bytes=ascii_props)
 
-    with codecs.open(output, 'a' if append else 'w', 'utf-8') as f:
+    with open(output, 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         f.write('%s_bidi_classes: dict[str, str] = {\n' % prefix)
@@ -882,9 +871,14 @@ def gen_uposix(table, posix_table, ascii_props):
     s -= set(posix_table["posixcntrl"])
     posix_table["posixprint"] = list(s)
 
-    # `ASCII: [\x00-\x7F]`
-    s = set(range(0, 0x7F + 1))
-    posix_table["posixascii"] = list(s)
+    # `Word: [\p{alnum}\p{M}\p{Pc}\p{JoinControl}]`
+    s = set(posix_table["alnum"])
+    for k, v in table['m'].items():
+        if not k.startswith('^'):
+            s |= set(v)
+    s |= set(table["p"]["c"])
+    s |= set(posix_table["joincontrol"])
+    posix_table['posixword'] = list(s)
 
 
 def gen_alias(nonbinary, binary, output):
@@ -905,15 +899,17 @@ def gen_alias(nonbinary, binary, output):
         'posixlower': 'lowercase',
         'posixupper': 'uppercase',
         'posixspace': 'whitespace',
+        'posixascii': 'basiclatin',
         'blank': 'posixblank',
         'graph': 'posixgraph',
-        'print': 'posixprint'
+        'print': 'posixprint',
+        'word': 'posixword'
     }
     toplevel = (
         'catalog', 'enumerated', 'numeric', 'miscellaneous'
     )
 
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'PropertyAliases.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'PropertyAliases.txt'), 'r', encoding='utf-8') as uf:
         div = False
         capture = False
         name = None
@@ -952,7 +948,7 @@ def gen_alias(nonbinary, binary, output):
                     for d in data[1:]:
                         alias[name][d] = data[0]
 
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'PropertyValueAliases.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'PropertyValueAliases.txt'), 'r', encoding='utf-8') as uf:
         for line in uf:
             m = alias_re.match(line)
             if m:
@@ -992,7 +988,7 @@ def gen_alias(nonbinary, binary, output):
     alias['binary']['h'] = 'horizspace'
     alias['binary']['v'] = 'vertspace'
 
-    with codecs.open(output, 'w', 'utf-8') as f:
+    with open(output, 'w', encoding='utf-8') as f:
         f.write(HEADER.format(UNIVERSION, TYPING))
         f.write('%s_alias: dict[str, dict[str, str]] = {\n' % prefix)
         count = len(alias) - 1
@@ -1037,7 +1033,7 @@ def gen_properties(output, files, aliases, ascii_props=False, append=False):
     # before sending it through.
     table = {'l': {'c': []}}
     itable = {'l': {}}
-    with codecs.open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'UnicodeData.txt'), 'r', 'utf-8') as uf:
+    with open(os.path.join(HOME, 'unicodedata', UNIVERSION, 'UnicodeData.txt'), 'r', encoding='utf-8') as uf:
         for line in uf:
             data = line.strip().split(';')
             if data:
@@ -1194,7 +1190,7 @@ def gen_properties(output, files, aliases, ascii_props=False, append=False):
     for k1, v1 in itable.items():
         table[k1]['^'] = v1['^']
 
-    with codecs.open(files['gc'], 'a' if append else 'w', 'utf-8') as f:
+    with open(files['gc'], 'a' if append else 'w', encoding='utf-8') as f:
         if not append:
             f.write(HEADER.format(UNIVERSION, TYPING))
         # Write out the Unicode properties
@@ -1219,7 +1215,7 @@ def gen_properties(output, files, aliases, ascii_props=False, append=False):
             i += 1
 
     if not append:
-        with codecs.open(os.path.join(output, '__init__.py'), 'w') as f:
+        with open(os.path.join(output, '__init__.py'), 'w') as f:
             f.write(HEADER.format(UNIVERSION, ''))
             for x in sorted(files):
                 f.write('from .%s import *  # noqa\n' % os.path.basename(files[x])[:-3])