ecma-regex 0.0.1__tar.gz

ecma_regex-0.0.1/.gitignore

@@ -0,0 +1,10 @@
+.venv/
+dist/
+build/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.DS_Store

ecma_regex-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Henry Andrews
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ecma_regex-0.0.1/PKG-INFO

@@ -0,0 +1,187 @@
+Metadata-Version: 2.5
+Name: ecma-regex
+Version: 0.0.1
+Summary: ECMA-262 regular expressions for Python: parse, translate to re, and search with JavaScript semantics
+Project-URL: Homepage, https://github.com/handrews/py-json-schema-engine/tree/main/packages/ecma-regex
+Project-URL: Repository, https://github.com/handrews/py-json-schema-engine
+Project-URL: Issues, https://github.com/handrews/py-json-schema-engine/issues
+Author: Henry Andrews
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ecma-262,ecmascript,javascript,regex,regexp,unicode
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.12
+Provides-Extra: regex
+Requires-Dist: regex; extra == 'regex'
+Description-Content-Type: text/markdown
+
+# ecma-regex
+
+ECMA-262 regular expressions for Python: parse them, translate them to `re`
+(or `regex`), and match with JavaScript semantics.
+
+Several widely used data formats specify their regular expressions as
+ECMA-262 patterns — JSON Schema above all. A Python program that hands
+those patterns straight to `re` does not get an error; it gets *different
+answers*, quietly, for `^`, `$`, `.`, `\d`, `\w`, `\s` and `\b`, and a hard
+failure for `\p{...}`. This package closes that gap.
+
+It has **no dependencies** and imports nothing from any consumer. It
+happens to power [json-schema-engine][engine], but it does not depend on
+it, and it is useful anywhere an ECMA-262 pattern has to run under Python.
+
+[engine]: https://github.com/handrews/py-json-schema-engine
+
+Produced by Henry Andrews via Claude Code.
+
+**Status: 0.0.x.** The implementation is functional and tested against every
+regular expression in the official JSON Schema test suite, but the
+documentation is AI-written and not yet audited against actual usage or
+human readability standards. `0.1.x` ships once the documentation is deemed
+suitable for general consumption.
+
+## Install
+
+```sh
+pip install ecma-regex
+# optional: the `regex` backend, which adds variable-width lookbehind
+# and native \p{Script=...} support
+pip install 'ecma-regex[regex]'
+```
+
+Python 3.12+.
+
+## Usage
+
+```python
+import ecma_regex
+
+pattern = ecma_regex.compile(r"^\p{Letter}+$")
+pattern.search("olé")  # True
+pattern.search("olé1")  # False
+pattern.translated  # the emitted `re` pattern
+pattern.compiled  # the underlying re.Pattern
+
+ecma_regex.compile("^a+$").search("aaa\n")  # False  (re says True)
+ecma_regex.compile("f.o").search("f\ro")  # False  (re says True)
+ecma_regex.compile(r"\d").search("٣")  # False  (re says True)
+ecma_regex.compile("^b$", flags="m").search("a\u2028b")  # True
+```
+
+`search` has `RegExp.prototype.test` semantics: unanchored, boolean.
+
+Lower-level entry points, if you want the pieces:
+
+```python
+tree = ecma_regex.parse(r"(?<year>\d{4})-\d{2}")  # an AST
+source = ecma_regex.translate(tree)  # a backend pattern string
+flags = ecma_regex.translate_flags(tree)  # re.IGNORECASE, or 0
+depth = ecma_regex.star_height(tree)  # ReDoS screening
+```
+
+`star_height` reports the nesting depth of unbounded quantifiers — `a+` is
+1, `(a+)+` is 2 — which is the classic necessary condition for
+catastrophic backtracking. It over-reports; it is a screen, not a proof.
+
+Nothing is cached at the `compile` level. Put your own cache in front of it
+if you compile the same pattern repeatedly.
+
+## Scope
+
+The dialect is ECMA-262 §22.2 with the **`u` flag**: the Unicode-mode
+pattern grammar. Annex B's web-compatibility leniencies (legacy octal
+escapes, quantifiable assertions, a bare `{` as a literal, identity escapes
+of arbitrary characters) are early errors under `u`, and they are errors
+here too. `a{,3}`, `a**` and `(?=a)*` all raise.
+
+| Flag | Status |
+| --- | --- |
+| `i` | supported (`re.IGNORECASE` at compile time) |
+| `m` | supported (spelled out with lookarounds, not `re.MULTILINE`) |
+| `s` | supported (spelled out, not `re.DOTALL`) |
+| `u` | accepted and always implied |
+| `g`, `y`, `d`, `v` | rejected — this models one stateless match |
+
+Everything the grammar allows is parsed: lookbehind, backreferences, named
+groups and `\k<name>`, `\uXXXX` (surrogate pairs combined), `\u{...}`,
+`\xHH`, `\cX`, `\0`, `\t\n\v\f\r`, and `\p{...}` / `\P{...}`.
+
+Invalid patterns raise `EcmaRegexSyntaxError`; valid-but-untranslatable
+ones raise `UnsupportedPatternError`. Both subclass `EcmaRegexError` and
+carry a `position`.
+
+## Divergence table
+
+What the translation fixes — each row is a silent change of verdict if the
+pattern goes to `re` unchanged.
+
+| Construct | Python `re` | ECMA-262 (what is emitted) |
+| --- | --- | --- |
+| `^` / `$` | `$` also matches before a final `\n` | `\A` / `\Z` |
+| `^` / `$` with `m` | line breaks are `\n` only | lookarounds over LF, CR, U+2028, U+2029 |
+| `.` | excludes `\n` only | excludes LF, CR, U+2028, U+2029 |
+| `.` with `s` | `re.DOTALL` | `[\s\S]` |
+| `\d` | any Unicode decimal digit | `[0-9]` |
+| `\w` | any Unicode word character | `[A-Za-z0-9_]` |
+| `\s` | a different set; misses U+FEFF, includes U+001C–U+001F | ECMA WhiteSpace ∪ LineTerminator |
+| `\b` / `\B` | Unicode word boundary | ASCII word boundary, as explicit lookarounds |
+| `\D` `\W` `\S` | as above, negated | explicit complement ranges |
+| `\D` `\W` `\S` **inside a class** | not expressible | explicit complement ranges |
+| `\p{...}` / `\P{...}` | `re.error` | explicit ranges (`re`) or native (`regex`) |
+| `(?<name>…)` | different spelling | `(?P<name>…)`, with `$` in names rewritten |
+| `\k<name>` | different spelling | `(?P=name)` |
+| literal `{`, `#`, `-`, … | may be metacharacters | escaped |
+
+## Residual divergences
+
+These cannot be closed inside a backend pattern, so they are documented
+rather than fixed.
+
+| Area | Difference |
+| --- | --- |
+| Case folding | `i` compiles with `re.IGNORECASE`, which is Python's *full* case folding; ECMA-262 `u` mode uses *simple* case folding. They agree except on a handful of code points. |
+| `\b` with `i` and `u` | ECMA-262 adds U+017F and U+212A to the word set in that combination; this package does not. |
+| Variable-width lookbehind | `re` requires a fixed width, so `(?<=ab?)c` raises `UnsupportedPatternError` on the `re` backend. It works on `regex`. |
+| `\p{Script=…}`, `\p{Script_Extensions=…}` | Parsed, but the standard library ships no script data: translatable only on the `regex` backend, and script *names* are not validated. |
+| Some binary properties | `Alphabetic`, `Math`, `Emoji`, `Cased`, … are recognized as valid syntax but not derivable from the standard library; they raise `UnsupportedPatternError` on `re` and are emitted natively on `regex`. |
+| Unicode version | Property sets come from the running interpreter's `unicodedata`, not from whatever version a given JavaScript engine ships. |
+
+Properties that *are* derivable everywhere: every `General_Category` value
+(including `\p{L}`, `\p{Letter}`, `\p{General_Category=Nd}`) plus `ASCII`,
+`ASCII_Hex_Digit`, `Any`, `Assigned`, `Bidi_Control`, `Bidi_Mirrored`,
+`Hex_Digit`, `Join_Control`, `Lowercase`, `Noncharacter_Code_Point`,
+`Regional_Indicator`, `Uppercase`, `White_Space`, `XID_Continue`,
+`XID_Start`.
+
+## Backends
+
+| Backend | Notes |
+| --- | --- |
+| `re` (default) | Standard library, no dependencies. `\p{...}` becomes an explicit range class. |
+| `regex` | Optional extra. Keeps `\p{...}` native, allows variable-width lookbehind, supports scripts. |
+
+```python
+ecma_regex.compile(r"\p{Script=Greek}+", backend="regex")
+```
+
+Neither backend is linear-time; both backtrack. Use `star_height` to screen
+untrusted patterns.
+
+### Cost
+
+The first `\p{...}` translated on the `re` backend scans every code point
+to build its range list — about 40 ms on CPython 3.12. The result is cached
+process-wide, so later uses are dict hits, and every later
+`General_Category` property reuses the same scan.
+
+## License
+
+MIT.

ecma_regex-0.0.1/README.md

@@ -0,0 +1,162 @@
+# ecma-regex
+
+ECMA-262 regular expressions for Python: parse them, translate them to `re`
+(or `regex`), and match with JavaScript semantics.
+
+Several widely used data formats specify their regular expressions as
+ECMA-262 patterns — JSON Schema above all. A Python program that hands
+those patterns straight to `re` does not get an error; it gets *different
+answers*, quietly, for `^`, `$`, `.`, `\d`, `\w`, `\s` and `\b`, and a hard
+failure for `\p{...}`. This package closes that gap.
+
+It has **no dependencies** and imports nothing from any consumer. It
+happens to power [json-schema-engine][engine], but it does not depend on
+it, and it is useful anywhere an ECMA-262 pattern has to run under Python.
+
+[engine]: https://github.com/handrews/py-json-schema-engine
+
+Produced by Henry Andrews via Claude Code.
+
+**Status: 0.0.x.** The implementation is functional and tested against every
+regular expression in the official JSON Schema test suite, but the
+documentation is AI-written and not yet audited against actual usage or
+human readability standards. `0.1.x` ships once the documentation is deemed
+suitable for general consumption.
+
+## Install
+
+```sh
+pip install ecma-regex
+# optional: the `regex` backend, which adds variable-width lookbehind
+# and native \p{Script=...} support
+pip install 'ecma-regex[regex]'
+```
+
+Python 3.12+.
+
+## Usage
+
+```python
+import ecma_regex
+
+pattern = ecma_regex.compile(r"^\p{Letter}+$")
+pattern.search("olé")  # True
+pattern.search("olé1")  # False
+pattern.translated  # the emitted `re` pattern
+pattern.compiled  # the underlying re.Pattern
+
+ecma_regex.compile("^a+$").search("aaa\n")  # False  (re says True)
+ecma_regex.compile("f.o").search("f\ro")  # False  (re says True)
+ecma_regex.compile(r"\d").search("٣")  # False  (re says True)
+ecma_regex.compile("^b$", flags="m").search("a\u2028b")  # True
+```
+
+`search` has `RegExp.prototype.test` semantics: unanchored, boolean.
+
+Lower-level entry points, if you want the pieces:
+
+```python
+tree = ecma_regex.parse(r"(?<year>\d{4})-\d{2}")  # an AST
+source = ecma_regex.translate(tree)  # a backend pattern string
+flags = ecma_regex.translate_flags(tree)  # re.IGNORECASE, or 0
+depth = ecma_regex.star_height(tree)  # ReDoS screening
+```
+
+`star_height` reports the nesting depth of unbounded quantifiers — `a+` is
+1, `(a+)+` is 2 — which is the classic necessary condition for
+catastrophic backtracking. It over-reports; it is a screen, not a proof.
+
+Nothing is cached at the `compile` level. Put your own cache in front of it
+if you compile the same pattern repeatedly.
+
+## Scope
+
+The dialect is ECMA-262 §22.2 with the **`u` flag**: the Unicode-mode
+pattern grammar. Annex B's web-compatibility leniencies (legacy octal
+escapes, quantifiable assertions, a bare `{` as a literal, identity escapes
+of arbitrary characters) are early errors under `u`, and they are errors
+here too. `a{,3}`, `a**` and `(?=a)*` all raise.
+
+| Flag | Status |
+| --- | --- |
+| `i` | supported (`re.IGNORECASE` at compile time) |
+| `m` | supported (spelled out with lookarounds, not `re.MULTILINE`) |
+| `s` | supported (spelled out, not `re.DOTALL`) |
+| `u` | accepted and always implied |
+| `g`, `y`, `d`, `v` | rejected — this models one stateless match |
+
+Everything the grammar allows is parsed: lookbehind, backreferences, named
+groups and `\k<name>`, `\uXXXX` (surrogate pairs combined), `\u{...}`,
+`\xHH`, `\cX`, `\0`, `\t\n\v\f\r`, and `\p{...}` / `\P{...}`.
+
+Invalid patterns raise `EcmaRegexSyntaxError`; valid-but-untranslatable
+ones raise `UnsupportedPatternError`. Both subclass `EcmaRegexError` and
+carry a `position`.
+
+## Divergence table
+
+What the translation fixes — each row is a silent change of verdict if the
+pattern goes to `re` unchanged.
+
+| Construct | Python `re` | ECMA-262 (what is emitted) |
+| --- | --- | --- |
+| `^` / `$` | `$` also matches before a final `\n` | `\A` / `\Z` |
+| `^` / `$` with `m` | line breaks are `\n` only | lookarounds over LF, CR, U+2028, U+2029 |
+| `.` | excludes `\n` only | excludes LF, CR, U+2028, U+2029 |
+| `.` with `s` | `re.DOTALL` | `[\s\S]` |
+| `\d` | any Unicode decimal digit | `[0-9]` |
+| `\w` | any Unicode word character | `[A-Za-z0-9_]` |
+| `\s` | a different set; misses U+FEFF, includes U+001C–U+001F | ECMA WhiteSpace ∪ LineTerminator |
+| `\b` / `\B` | Unicode word boundary | ASCII word boundary, as explicit lookarounds |
+| `\D` `\W` `\S` | as above, negated | explicit complement ranges |
+| `\D` `\W` `\S` **inside a class** | not expressible | explicit complement ranges |
+| `\p{...}` / `\P{...}` | `re.error` | explicit ranges (`re`) or native (`regex`) |
+| `(?<name>…)` | different spelling | `(?P<name>…)`, with `$` in names rewritten |
+| `\k<name>` | different spelling | `(?P=name)` |
+| literal `{`, `#`, `-`, … | may be metacharacters | escaped |
+
+## Residual divergences
+
+These cannot be closed inside a backend pattern, so they are documented
+rather than fixed.
+
+| Area | Difference |
+| --- | --- |
+| Case folding | `i` compiles with `re.IGNORECASE`, which is Python's *full* case folding; ECMA-262 `u` mode uses *simple* case folding. They agree except on a handful of code points. |
+| `\b` with `i` and `u` | ECMA-262 adds U+017F and U+212A to the word set in that combination; this package does not. |
+| Variable-width lookbehind | `re` requires a fixed width, so `(?<=ab?)c` raises `UnsupportedPatternError` on the `re` backend. It works on `regex`. |
+| `\p{Script=…}`, `\p{Script_Extensions=…}` | Parsed, but the standard library ships no script data: translatable only on the `regex` backend, and script *names* are not validated. |
+| Some binary properties | `Alphabetic`, `Math`, `Emoji`, `Cased`, … are recognized as valid syntax but not derivable from the standard library; they raise `UnsupportedPatternError` on `re` and are emitted natively on `regex`. |
+| Unicode version | Property sets come from the running interpreter's `unicodedata`, not from whatever version a given JavaScript engine ships. |
+
+Properties that *are* derivable everywhere: every `General_Category` value
+(including `\p{L}`, `\p{Letter}`, `\p{General_Category=Nd}`) plus `ASCII`,
+`ASCII_Hex_Digit`, `Any`, `Assigned`, `Bidi_Control`, `Bidi_Mirrored`,
+`Hex_Digit`, `Join_Control`, `Lowercase`, `Noncharacter_Code_Point`,
+`Regional_Indicator`, `Uppercase`, `White_Space`, `XID_Continue`,
+`XID_Start`.
+
+## Backends
+
+| Backend | Notes |
+| --- | --- |
+| `re` (default) | Standard library, no dependencies. `\p{...}` becomes an explicit range class. |
+| `regex` | Optional extra. Keeps `\p{...}` native, allows variable-width lookbehind, supports scripts. |
+
+```python
+ecma_regex.compile(r"\p{Script=Greek}+", backend="regex")
+```
+
+Neither backend is linear-time; both backtrack. Use `star_height` to screen
+untrusted patterns.
+
+### Cost
+
+The first `\p{...}` translated on the `re` backend scans every code point
+to build its range list — about 40 ms on CPython 3.12. The result is cached
+process-wide, so later uses are dict hits, and every later
+`General_Category` property reuses the same scan.
+
+## License
+
+MIT.

ecma_regex-0.0.1/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ecma-regex"
+version = "0.0.1"
+description = "ECMA-262 regular expressions for Python: parse, translate to re, and search with JavaScript semantics"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Henry Andrews" },
+]
+dependencies = []
+keywords = ["regex", "regexp", "ecmascript", "ecma-262", "javascript", "unicode"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Text Processing",
+]
+
+[project.optional-dependencies]
+regex = ["regex"]
+
+[project.urls]
+Homepage = "https://github.com/handrews/py-json-schema-engine/tree/main/packages/ecma-regex"
+Repository = "https://github.com/handrews/py-json-schema-engine"
+Issues = "https://github.com/handrews/py-json-schema-engine/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ecma_regex"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src/",
+    "/tests/",
+    "/README.md",
+    "/LICENSE",
+    "/pyproject.toml",
+]

ecma_regex-0.0.1/src/ecma_regex/__init__.py

@@ -0,0 +1,156 @@
+"""ECMA-262 regular expressions for Python.
+
+Parse an ECMA-262 pattern, translate it into a pattern string for Python's
+:mod:`re` (or the third-party ``regex`` module), and match with JavaScript
+semantics. This exists because several widely used data formats -- JSON
+Schema above all -- specify their regular expressions as ECMA-262
+patterns, and a Python program that hands those patterns straight to
+:mod:`re` silently gets different answers.
+
+    >>> import ecma_regex
+    >>> ecma_regex.compile("^a+$").search("aaa\\n")
+    False
+    >>> ecma_regex.compile(r"^\\p{Letter}+$").search("ol\\u00e9")
+    True
+
+Scope
+-----
+The dialect implemented is ECMA-262 22.2 with the ``u`` flag: the
+Unicode-mode pattern grammar, which is strict where the web-compatibility
+grammar of Annex B is lenient. ``i``, ``m`` and ``s`` are supported and
+recorded on the AST; ``u`` is accepted and implied. The stateful flags
+``g`` and ``y``, the index flag ``d`` and the ``v`` set-notation flag are
+rejected: this package models a single stateless, unanchored match.
+
+Everything the grammar allows is parsed, including lookbehind, named
+groups and named backreferences, ``\\uXXXX`` (with surrogate-pair
+combining), ``\\u{...}``, ``\\xHH``, ``\\cX``, ``\\0``, and ``\\p{...}`` /
+``\\P{...}`` property escapes.
+
+What the translation fixes
+--------------------------
+Each of these silently changes a verdict if a pattern is handed to
+:mod:`re` unchanged. The emitted pattern spells out the ECMA-262 meaning.
+
+==================  =========================  ============================
+Construct           Python ``re``              ECMA-262 (what is emitted)
+==================  =========================  ============================
+``^`` / ``$``       ``$`` also matches before  ``\\A`` / ``\\Z``
+                    a final ``\\n``
+``^`` / ``$`` (m)   line breaks are ``\\n``    lookarounds over LF, CR,
+                    only                       LS (U+2028), PS (U+2029)
+``.``               excludes ``\\n`` only      excludes LF, CR, LS, PS
+``\\d``             any Unicode decimal        ``[0-9]``
+``\\w``             any Unicode word char      ``[A-Za-z0-9_]``
+``\\s``             a different space set      ECMA WhiteSpace plus
+                                               LineTerminator, incl. U+FEFF
+                                               and excl. U+001C-U+001F
+``\\b``             Unicode word boundary      ASCII word boundary
+``\\D \\W \\S``     as above, negated          explicit complement ranges,
+                                               inside classes too
+``\\p{...}``        rejected outright          explicit ranges (``re``) or
+                                               native (``regex``)
+``(?<name>)``       ``(?P<name>)``             rewritten, ``$`` in names
+                                               escaped
+``\\k<name>``       ``(?P=name)``              rewritten
+==================  =========================  ============================
+
+Residual divergences
+--------------------
+These cannot be closed inside a backend pattern and are documented rather
+than fixed:
+
+* **Case folding.** The ``i`` flag compiles with ``re.IGNORECASE``, which
+  applies Python's full case folding. ECMA-262 ``u`` mode uses *simple*
+  case folding. The two agree on everything but a handful of code points
+  (for example Python folds ``ß`` to ``ss``-like equivalences that
+  ECMA-262 does not).
+* **``\\b`` with both ``i`` and ``u``.** ECMA-262 adds U+017F and U+212A
+  to the word-character set in that combination. This package does not.
+* **Variable-width lookbehind.** Python's :mod:`re` requires a fixed
+  width, so a variable-width lookbehind raises
+  :class:`UnsupportedPatternError` on the ``re`` backend. It works on the
+  ``regex`` backend.
+* **Unicode scripts.** ``\\p{Script=...}`` and
+  ``\\p{Script_Extensions=...}`` parse, but the standard library ships no
+  script data, so they are only translatable on the ``regex`` backend, and
+  script *names* are not validated. General_Category values are validated
+  and translatable everywhere.
+* **Binary properties.** Those derivable from the standard library
+  (``ASCII``, ``Assigned``, ``Any``, ``White_Space``, ``Lowercase``,
+  ``Uppercase``, ``XID_Start``, ``XID_Continue``, ``Hex_Digit``,
+  ``ASCII_Hex_Digit``, ``Bidi_Control``, ``Bidi_Mirrored``,
+  ``Join_Control``, ``Noncharacter_Code_Point``, ``Regional_Indicator``)
+  are translatable on both backends. The remaining ECMA-262 binary
+  properties (``Alphabetic``, ``Math``, ``Emoji``, ...) are recognized as
+  valid syntax but raise :class:`UnsupportedPatternError` on ``re``.
+* **Unicode version.** Property sets come from the running interpreter's
+  :mod:`unicodedata`, not from the Unicode version a given JavaScript
+  engine ships.
+
+Cost
+----
+The first ``\\p{...}`` translated on the ``re`` backend scans every code
+point to build its range list (roughly 50 ms for a General_Category
+property, up to a few hundred for a predicate-derived binary property).
+The result is cached process-wide, so every later use is a dict hit.
+"""
+
+from .analysis import star_height, width
+from .ast import (
+    Alternation,
+    Anchor,
+    Backreference,
+    CharClass,
+    ClassEscape,
+    ClassItem,
+    ClassRange,
+    Concatenation,
+    Dot,
+    Flags,
+    Group,
+    Literal,
+    Lookaround,
+    Node,
+    Pattern,
+    PropertyEscape,
+    Quantifier,
+    WordBoundary,
+)
+from .errors import EcmaRegexError, EcmaRegexSyntaxError, UnsupportedPatternError
+from .matcher import CompiledPattern, EcmaRegex, compile
+from .parser import parse
+from .translator import BackendName, translate, translate_flags
+
+__all__ = [
+    "Alternation",
+    "Anchor",
+    "BackendName",
+    "Backreference",
+    "CharClass",
+    "ClassEscape",
+    "ClassItem",
+    "ClassRange",
+    "CompiledPattern",
+    "Concatenation",
+    "Dot",
+    "EcmaRegex",
+    "EcmaRegexError",
+    "EcmaRegexSyntaxError",
+    "Flags",
+    "Group",
+    "Literal",
+    "Lookaround",
+    "Node",
+    "Pattern",
+    "PropertyEscape",
+    "Quantifier",
+    "UnsupportedPatternError",
+    "WordBoundary",
+    "compile",
+    "parse",
+    "star_height",
+    "translate",
+    "translate_flags",
+    "width",
+]

ecma_regex-0.0.1/src/ecma_regex/analysis.py

@@ -0,0 +1,95 @@
+"""Static analyses over a parsed pattern: star height and match width."""
+
+from __future__ import annotations
+
+from .ast import (
+    Alternation,
+    Anchor,
+    Backreference,
+    CharClass,
+    ClassEscape,
+    Concatenation,
+    Dot,
+    Group,
+    Literal,
+    Lookaround,
+    Node,
+    Pattern,
+    PropertyEscape,
+    Quantifier,
+    WordBoundary,
+)
+
+__all__ = ["is_fixed_width", "star_height", "width"]
+
+
+def star_height(pattern: Pattern) -> int:
+    """The nesting depth of unbounded quantifiers in ``pattern``.
+
+    ``a`` is 0, ``a+`` is 1, ``(a+)+`` is 2. Bounded quantifiers such as
+    ``a{2,3}`` do not count; ``a{2,}`` does. A star height of 2 or more is
+    the classic screen for catastrophic backtracking (ReDoS): it is a
+    necessary condition, not a sufficient one, so it over-reports.
+    """
+    return _height(pattern.root)
+
+
+def _height(node: Node) -> int:
+    match node:
+        case Quantifier(target=target, max=None):
+            return 1 + _height(target)
+        case Quantifier(target=target):
+            return _height(target)
+        case Alternation(options=children):
+            return max((_height(child) for child in children), default=0)
+        case Concatenation(parts=children):
+            return max((_height(child) for child in children), default=0)
+        case Group(body=body) | Lookaround(body=body):
+            return _height(body)
+        case _:
+            return 0
+
+
+def width(node: Node) -> tuple[int, int | None]:
+    """The ``(minimum, maximum)`` number of code points ``node`` consumes.
+
+    ``maximum`` is ``None`` when it is unbounded or not statically known
+    (a backreference). A node is fixed-width when the two are equal.
+    """
+    match node:
+        case Literal() | Dot() | CharClass() | ClassEscape() | PropertyEscape():
+            return 1, 1
+        case Anchor() | WordBoundary() | Lookaround():
+            return 0, 0
+        case Backreference():
+            return 0, None
+        case Group(body=body):
+            return width(body)
+        case Concatenation(parts=parts):
+            low = 0
+            high: int | None = 0
+            for part in parts:
+                part_low, part_high = width(part)
+                low += part_low
+                high = None if high is None or part_high is None else high + part_high
+            return low, high
+        case Alternation(options=options):
+            widths = [width(option) for option in options]
+            low = min(bounds[0] for bounds in widths)
+            high = (
+                None
+                if any(bounds[1] is None for bounds in widths)
+                else max(bounds[1] for bounds in widths if bounds[1] is not None)
+            )
+            return low, high
+        case Quantifier(target=target, min=minimum, max=maximum):
+            target_low, target_high = width(target)
+            if maximum is None or target_high is None:
+                return target_low * minimum, None
+            return target_low * minimum, target_high * maximum
+
+
+def is_fixed_width(node: Node) -> bool:
+    """Whether ``node`` always consumes the same number of code points."""
+    low, high = width(node)
+    return high is not None and low == high