backrefs 8.0__tar.gz → 8.2__tar.gz

{backrefs-8.0 → backrefs-8.2}/.pyspelling.yml

@@ -18,11 +18,10 @@ matrix:
       - alt
       ignores:
       - 'code, pre'
-      - 'a:is(.magiclink-compare, .magiclink-commit, .magiclink-repository)'
       - 'span.keys'
       - '.MathJax_Preview, .md-nav__link, .md-footer-custom-text, .md-source__repository, .headerlink, .md-icon'
-      - '.md-social__link, .magiclink-issue'
-  
+      - '.md-social__link, .magiclink'
+
   - pyspelling.filters.url:
 
 - name: markdown

{backrefs-8.0 → backrefs-8.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: backrefs
-Version: 8.0
+Version: 8.2
 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>
@@ -13,14 +13,14 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-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: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Provides-Extra: extras
 Requires-Dist: regex; extra == 'extras'
 Description-Content-Type: text/markdown

{backrefs-8.0 → backrefs-8.2}/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(8, 0, 0, "final")
+__version_info__ = Version(8, 2, 0, "final")
 __version__ = __version_info__._get_canonical()

{backrefs-8.0 → backrefs-8.2}/backrefs/_bre_parse.py

@@ -10,7 +10,6 @@ import sys
 import copyreg as _copyreg
 from . import util as _util
 from .util import PatternError
-import unicodedata as _unicodedata
 from . import uniprops as _uniprops
 from typing import Generic, AnyStr, Match, Any, Pattern, cast
 
@@ -37,7 +36,7 @@ _WORD = _LETTERS_UNDERSCORE | _DIGIT
 _STANDARD_ESCAPES = frozenset(('a', 'b', 'f', 'n', 'r', 't', 'v'))
 _CURLY_BRACKETS = frozenset(('{', '}'))
 _PROPERTY_STRIP = frozenset((' ', '-', '_'))
-_PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP
+_PROPERTY = _WORD | _DIGIT | _PROPERTY_STRIP | frozenset(('.',))
 _SCOPED_FLAGS = frozenset(('a', 'i', 'L', 'm', 'u', 's', 'x'))
 _SCOPED_INV_FLAGS = frozenset(('i', 'm', 's', 'x'))
 _SCOPED_END = frozenset((':', ')'))
@@ -176,7 +175,7 @@ class _SearchParser(Generic[AnyStr]):
         value = []
         try:
             c = next(i)
-            if c.upper() in _ASCII_LETTERS:
+            if not brackets and c.upper() in _ASCII_LETTERS:
                 prop.append(c)
             elif (not brackets and c != '{') or (brackets and c != ':'):
                 raise PatternError(f"Unicode property missing '{{' at {i.index - 1}!")
@@ -533,7 +532,7 @@ class _SearchParser(Generic[AnyStr]):
     def unicode_name(self, name: str, in_group: bool = False) -> list[str]:
         """Insert Unicode value by its name."""
 
-        value = ord(_unicodedata.lookup(name))
+        value = ord(_util.unicode_char(name))
         if self.is_bytes and value > 0xFF:
             if not in_group:
                 return ['(?!)']
@@ -755,7 +754,7 @@ class _ReplaceParser(Generic[AnyStr]):
                         else:
                             width.append(fill)
                             fill = None
-                    else:
+                    elif c != '}':
                         fill = c
                         c = self.format_next(i)
                         if fill == 's' and c == '}':
@@ -852,6 +851,18 @@ class _ReplaceParser(Generic[AnyStr]):
 
         return ''.join(value) if value else None
 
+    def append_chars(self, text: str, i: _util.StringIter) -> None:
+        """Append each character of an escape value as a template escape."""
+
+        for c in text:
+            value = ord(c)
+            if self.use_format and value in _CURLY_BRACKETS_ORD:
+                self.handle_format(c, i)
+            elif value <= 0xFF:
+                self.result.append(f'\\{value:03o}')
+            else:
+                self.result.append(c)
+
     def parse_octal(self, text: str, i: _util.StringIter) -> None:
         """Parse octal value."""
 
@@ -863,15 +874,12 @@ class _ReplaceParser(Generic[AnyStr]):
             single = self.get_single_stack()
             if self.span_stack:
                 text = self.convert_case(chr(value), self.span_stack[-1])
-                value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+                text = self.convert_case(text, single) if single is not None else text
             elif single:
-                value = ord(self.convert_case(chr(value), single))
-            if self.use_format and value in _CURLY_BRACKETS_ORD:
-                self.handle_format(chr(value), i)
-            elif value <= 0xFF:
-                self.result.append(f'\\{value:03o}')
+                text = self.convert_case(chr(value), single)
             else:
-                self.result.append(chr(value))
+                text = chr(value)
+            self.append_chars(text, i)
 
     def get_named_unicode(self, i: _util.StringIter) -> str:
         """Get named Unicode."""
@@ -893,19 +901,16 @@ class _ReplaceParser(Generic[AnyStr]):
     def parse_named_unicode(self, i: _util.StringIter) -> None:
         """Parse named Unicode."""
 
-        value = ord(_unicodedata.lookup(self.get_named_unicode(i)))
+        value = ord(_util.unicode_char(self.get_named_unicode(i)))
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
-        elif value <= 0xFF:
-            self.result.append(f'\\{value:03o}')
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(chr(value))
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_wide_unicode(self, i: _util.StringIter) -> str:
         """Get narrow Unicode."""
@@ -952,15 +957,12 @@ class _ReplaceParser(Generic[AnyStr]):
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
-        elif value <= 0xFF:
-            self.result.append(f'\\{value:03o}')
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(chr(value))
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_byte(self, i: _util.StringIter) -> str:
         """Get byte."""
@@ -981,13 +983,12 @@ class _ReplaceParser(Generic[AnyStr]):
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(f'\\{value:03o}')
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_named_group(self, t: str, i: _util.StringIter) -> str:
         """Get group number."""
@@ -1004,16 +1005,18 @@ class _ReplaceParser(Generic[AnyStr]):
                 value.append(c)
                 c = next(i)
                 while c != '>':
-                    if c in _DIGIT:
-                        value.append(c)
+                    if c not in _DIGIT:
+                        raise PatternError(f"Bad character in group name at {i.index - 1}!")
+                    value.append(c)
                     c = next(i)
                 value.append(c)
             elif c in _LETTERS_UNDERSCORE:
                 value.append(c)
                 c = next(i)
                 while c != '>':
-                    if c in _WORD:
-                        value.append(c)
+                    if c not in _WORD:
+                        raise PatternError(f"Bad character in group name at {i.index - 1}!")
+                    value.append(c)
                     c = next(i)
                 value.append(c)
             else:
@@ -1062,7 +1065,7 @@ class _ReplaceParser(Generic[AnyStr]):
         elif not self.is_bytes and t == "u":
             value = chr(int(self.get_narrow_unicode(i), 16))
         elif not self.is_bytes and t == "N":
-            value = _unicodedata.lookup(self.get_named_unicode(i))
+            value = _util.unicode_char(self.get_named_unicode(i))
         elif t == "x":
             value = chr(int(self.get_byte(i), 16))
         else:

{backrefs-8.0 → backrefs-8.2}/backrefs/_bregex_parse.py

@@ -5,7 +5,6 @@ Licensed under MIT
 Copyright (c) 2011 - 2020 Isaac Muse <isaacmuse@gmail.com>
 """
 from __future__ import annotations
-import unicodedata as _unicodedata
 import copyreg as _copyreg
 from . import util as _util
 from .util import PatternError
@@ -599,7 +598,7 @@ class _ReplaceParser(Generic[AnyStr]):
                         else:
                             width.append(fill)
                             fill = None
-                    else:
+                    elif c != '}':
                         fill = c
                         c = self.format_next(i)
                         if fill == 's' and c == '}':
@@ -696,6 +695,18 @@ class _ReplaceParser(Generic[AnyStr]):
 
         return ''.join(value) if value else None
 
+    def append_chars(self, text: str, i: _util.StringIter) -> None:
+        """Append each character of an escape value as a template escape."""
+
+        for c in text:
+            value = ord(c)
+            if self.use_format and value in _CURLY_BRACKETS_ORD:
+                self.handle_format(c, i)
+            elif value <= 0xFF:
+                self.result.append(f'\\{value:03o}')
+            else:
+                self.result.append(c)
+
     def parse_octal(self, text: str, i: _util.StringIter) -> None:
         """Parse octal value."""
 
@@ -707,15 +718,12 @@ class _ReplaceParser(Generic[AnyStr]):
             single = self.get_single_stack()
             if self.span_stack:
                 text = self.convert_case(chr(value), self.span_stack[-1])
-                value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+                text = self.convert_case(text, single) if single is not None else text
             elif single:
-                value = ord(self.convert_case(chr(value), single))
-            if self.use_format and value in _CURLY_BRACKETS_ORD:
-                self.handle_format(chr(value), i)
-            elif value <= 0xFF:
-                self.result.append(f'\\{value:03o}')
+                text = self.convert_case(chr(value), single)
             else:
-                self.result.append(chr(value))
+                text = chr(value)
+            self.append_chars(text, i)
 
     def get_named_unicode(self, i: _util.StringIter) -> str:
         """Get named Unicode."""
@@ -737,19 +745,16 @@ class _ReplaceParser(Generic[AnyStr]):
     def parse_named_unicode(self, i: _util.StringIter) -> None:
         """Parse named Unicode."""
 
-        value = ord(_unicodedata.lookup(self.get_named_unicode(i)))
+        value = ord(_util.unicode_char(self.get_named_unicode(i)))
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
-        elif value <= 0xFF:
-            self.result.append(f'\\{value:03o}')
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(chr(value))
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_wide_unicode(self, i: _util.StringIter) -> str:
         """Get narrow Unicode."""
@@ -796,15 +801,12 @@ class _ReplaceParser(Generic[AnyStr]):
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
-        elif value <= 0xFF:
-            self.result.append(f'\\{value:03o}')
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(chr(value))
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_byte(self, i: _util.StringIter) -> str:
         """Get byte."""
@@ -825,13 +827,12 @@ class _ReplaceParser(Generic[AnyStr]):
         single = self.get_single_stack()
         if self.span_stack:
             text = self.convert_case(chr(value), self.span_stack[-1])
-            value = ord(self.convert_case(text, single)) if single is not None else ord(text)
+            text = self.convert_case(text, single) if single is not None else text
         elif single:
-            value = ord(self.convert_case(chr(value), single))
-        if self.use_format and value in _CURLY_BRACKETS_ORD:
-            self.handle_format(chr(value), i)
+            text = self.convert_case(chr(value), single)
         else:
-            self.result.append(f'\\{value:03o}')
+            text = chr(value)
+        self.append_chars(text, i)
 
     def get_named_group(self, t: str, i: _util.StringIter) -> str:
         """Get group number."""
@@ -848,16 +849,18 @@ class _ReplaceParser(Generic[AnyStr]):
                 value.append(c)
                 c = next(i)
                 while c != '>':
-                    if c in _DIGIT:
-                        value.append(c)
+                    if c not in _DIGIT:
+                        raise PatternError(f"Bad character in group name at {i.index - 1}!")
+                    value.append(c)
                     c = next(i)
                 value.append(c)
             elif c in _LETTERS_UNDERSCORE:
                 value.append(c)
                 c = next(i)
                 while c != '>':
-                    if c in _WORD:
-                        value.append(c)
+                    if c not in _WORD:
+                        raise PatternError(f"Bad character in group name at {i.index - 1}!")
+                    value.append(c)
                     c = next(i)
                 value.append(c)
             else:
@@ -906,7 +909,7 @@ class _ReplaceParser(Generic[AnyStr]):
         elif not self.is_bytes and t == "u":
             value = chr(int(self.get_narrow_unicode(i), 16))
         elif not self.is_bytes and t == "N":
-            value = _unicodedata.lookup(self.get_named_unicode(i))
+            value = _util.unicode_char(self.get_named_unicode(i))
         elif t == "x":
             value = chr(int(self.get_byte(i), 16))
         else:

{backrefs-8.0 → backrefs-8.2}/backrefs/util.py

@@ -7,6 +7,7 @@ Copyright (c) 2015 - 2020 Isaac Muse <isaacmuse@gmail.com>
 from __future__ import annotations
 import warnings
 import sys
+import unicodedata as _unicodedata
 from typing import Any, Callable, AnyStr
 
 PY311 = (3, 11) <= sys.version_info
@@ -23,6 +24,15 @@ class PatternError(Exception):
     """Pattern error."""
 
 
+def unicode_char(name: str) -> str:
+    """Unicode character by its official name, raising our pattern error when no character has it."""
+
+    try:
+        return _unicodedata.lookup(name)
+    except KeyError as e:
+        raise PatternError(f"Undefined Unicode character name {name!r}!") from e
+
+
 class StringIter:
     """Preprocess replace tokens."""
 

backrefs-8.2/docs/src/dictionary/en-custom.txt

@@ -0,0 +1,67 @@
+API
+Accessors
+Backport
+Backrefs
+Bre
+Bregex
+CVE
+Changelog
+EmojiOne
+Feb
+Formatter
+GitHub
+Gitter
+Jan
+Jun
+MERCHANTABILITY
+Mar
+MkDocs
+NONINFRINGEMENT
+Posix
+PyMdown
+PyPI
+PyPI's
+Regex
+Regex's
+Sep
+Tidelift
+Tox
+Twemoji
+Zensical
+accessor
+backend
+boolean
+decrement
+deprecations
+emoji
+enablement
+formatter
+grapheme
+hashable
+incrementing
+namespaced
+natively
+parsers
+plugin
+posix
+postfix
+pre
+preprocess
+preprocesses
+preprocessing
+preprocessor
+prerelease
+prereleases
+refactored
+reinstalling
+reparsing
+requesters
+sublicense
+subpattern
+subpatterns
+tuple
+uncompiled
+unescaped
+unterminated
+validator
+whitespace

backrefs-8.2/docs/src/dictionary/en-python.txt

@@ -0,0 +1,15 @@
+BOM
+BOMs
+Bre
+Preprocess
+UTF
+backref
+backrefs
+bidi
+bregex
+builtin
+enum
+expander
+regex
+sortable
+whitespace

{backrefs-8.0 → backrefs-8.2}/docs/src/markdown/about/changelog.md

@@ -3,6 +3,27 @@ icon: lucide/scroll-text
 ---
 # Changelog
 
+## 8.2
+
+-   **NEW**: Drop Python 3.10.
+-   **FIX**: Fix error in replace templates when casing a character escape gives two characters (`\C\xdf\E`).
+-   **FIX**: Fix wrong text or errors when case conversion of a `\x` escape exceeds the byte range in replace templates.
+-   **FIX**: Fix an empty format specification (`{1:}`) raising an error in format replace templates.
+-   **FIX**: Fix Unicode properties, such as general category `\p{L}` and `\p{Bidi_Class=L}`, not matching ideographs,
+    Hangul syllables, and other characters Unicode defines as ranges.
+-   **FIX**: Fix `\g<...>` references in replace templates silently dropping invalid characters in a group name
+    instead of raising an error.
+-   **FIX**: Fix `\p{...}` Unicode properties rejecting the canonical dotted value form (e.g. `Age=1.1`),
+    which previously only worked through the alias form (e.g. `V1_1`).
+-   **FIX**: Fix issue where Unicode properties within character classes (e.g. `[x[:property:]]`) were incorrectly
+    detected with `[x[l]]` (@rahul05ranjan).
+-   **FIX**: Fix an undefined Unicode name in `\N{...}` raising a `KeyError` instead of `PatternError`
+    (@rahul05ranjan).
+
+## 8.1
+
+-   **NEW**: Add official support for Python 3.15.
+
 ## 8.0
 
 -   **NEW**: Backrefs will preemptively fail, raising a `PatternError`, if parsing and finding an unterminated character
@@ -132,7 +153,7 @@ icon: lucide/scroll-text
     to improve result.
 -   **NEW**: POSIX style properties now handle all existing Unicode properties.
 -   **NEW**: POSIX properties now follow the [Unicode specification for POSIX compatibility][unicode-posix].
-    Read the [documentation](../refs.md#posix-style-properties) to learn more.
+    Read the [documentation](../refs.md#posix-character-classes) to learn more.
 -   **NEW**: Unicode properties are now sensitive to the `ASCII` flag and will properly restrict the range of properties
     to the ASCII range even in Unicode strings.
 -   **NEW**: Removed the old deprecated search references: `\l`, `\L`, `\c`, and `\C`. These are available in various

{backrefs-8.0 → backrefs-8.2}/docs/src/markdown/about/contributing.md

@@ -45,6 +45,12 @@ any tier you feel comfortable with. No amount is too little. We also accept one
 Take part in reviewing pull requests and/or reviewing direct commits.  Make suggestions to improve the code and discuss
 solutions to overcome weakness in the algorithm.
 
+## Answer Questions in Issues
+
+Take time and answer questions and offer suggestions to people who've created issues in the issue tracker. Often people
+will have questions that you might have an answer for.  Or maybe you know how to help them accomplish a specific task
+they are asking about. Feel free to share your experience to help others.
+
 ## Pull Requests
 
 Pull requests are welcome, and if you plan on contributing directly to the code, there are a couple of things to be
@@ -55,23 +61,28 @@ tests will automatically be run, and the request must pass to be accepted.  You
 pull requesting.  If it is not possible to run these tests locally, they will be run when the pull request is made, but
 it is strongly suggested that requesters make an effort to verify before requesting to allow for a quick, smooth merge.
 
-Feel free to use a virtual environment if you are concerned about installing any of the Python packages.
-
 ### Running Validation Tests
 
-1.  Make sure that [Tox][tox] is installed:
+In order to preserve good code health, a test suite has been put together with `pytest` (@pytest-dev/pytest). There are
+currently two kinds of tests: syntax and targeted.  To run these tests, you can use the following command:
 
-    ```
-    pip install tox
-    ```
+If you wish to run the tests locally, just run:
 
-2.  Run Tox:
+```console
+$ hatch run +py=3.14 dev:tests
+```
 
-    ```
-    tox
-    ```
+Coding standards are enforced using @astral-sh/ruff. The environment can be setup and run as shown below.
 
-    Tox should install necessary dependencies and run the tests.
+```console
+$ hatch run +py=3.14 dev:lint
+```
+
+We use @python/mypy to enforce typing. It can be run as shown below.
+
+```console
+$ hatch run +py=3.14 dev:mypy
+```
 
 ## Documentation Improvements
 
@@ -80,7 +91,23 @@ you feel it is still lacking, show your appreciation for the plugin by helping t
 documentation is always appreciated and can be done via pull requests.  There shouldn't be any need to run validation
 tests if only updating documentation.
 
-You don't have to render the docs locally before pull requesting, but if you wish to, I currently use a combination of
-[MkDocs][mkdocs], the [Material theme][mkdocs-material], and [PyMdown Extensions][pymdown-extensions] to render the
-docs. You can preview the docs if you install these two packages.  The command for previewing the docs is `mkdocs serve`
-from the root directory. You can then view the documents at `localhost:8000`.
+Documents are in Markdown (with some additional syntax) and converted to HTML via Python Markdown and this extension
+bundle. The documentation site is built with @zensical/zensical.
+
+To build docs:
+
+```console
+$ hatch run docs:build
+```
+
+To serve docs and to live preview in a browser:
+
+```console
+$ hatch run docs:serve
+```
+
+To clean the documents:
+
+```console
+$ hatch run docs:clean
+```

{backrefs-8.0 → backrefs-8.2}/docs/src/markdown/refs.md

@@ -23,7 +23,7 @@ Back\ References      | Description
 `\pX`                 | Unicode property character class where `X` is the uppercase letter that represents the General Category property.  For instance, `\pL` would be equivalent to `\p{L}` or `\p{Letter}`.
 `\P{UnicodeProperty}` | Inverse Unicode property character class. Can be used in character classes `[]`. See [Unicode Properties](#unicode-properties) for more info.
 `\PX`                 | Inverse Unicode property character class where `X` is the uppercase letter that represents the General Category property. For instance, `\PL` would be equivalent to `\P{L}` or `\P{Letter}`.
-`[[:alnum:]]`         | Though not really a back reference, support for POSIX style character classes is available. See [POSIX Style Properties](#posix-style-properties) for more info.
+`[[:alnum:]]`         | Though not really a back reference, support for POSIX style character classes is available. See [POSIX Style Properties](#posix-character-classes) for more info.
 `\N{UnicodeName}`     | Named characters are normally ignored in Re, but Backrefs adds support for them.
 `\m`                  | Start word boundary. Translates to `\b(?=\w)`.
 `\M`                  | End word boundary. Translates to `\b(?<=\w)`.
@@ -92,7 +92,7 @@ implementation of Unicode properties. Some properties may not be available on ce
 included Unicode build.
 
 It is important to note that Backrefs handles Unicode properties by transforming them to character classes with all the
-associated characters: `\p{Cs}` --> `[\ud800\udb7f-\udb80\udbff-\udc00\udfff]`.  Because of this, Backrefs can create
+associated characters: `\p{Cs}` --> `[\ud800-\udfff]`.  Because of this, Backrefs can create
 really large regular expressions that the underlying engine must walk through.  In short, Re with Backrefs will never be
 as efficient or fast as using Regex's Unicode properties, but it is very useful when you need or want to use Re.