From 6acaba7ec4f4468db6a6b4e22c8413ac6d21d218 Mon Sep 17 00:00:00 2001
From: Marko Lahma <marko.lahma@gmail.com>
Date: Sat, 11 Apr 2026 11:38:39 +0300
Subject: [PATCH] Add custom JavaScript regex engine (QuickJS libregexp port)

Port of QuickJS libregexp to C# for patterns where .NET Regex diverges
from ECMAScript semantics. Three-tier architecture: direct .NET Regex
for simple patterns, Jint's converter for patterns needing rewriting,
and custom bytecode engine for ECMAScript-specific semantics.

97,638 test262 passed, 0 failures (+1,624 from baseline).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 Directory.Packages.props                      |    4 +-
 .../Test262Harness.settings.json              |   59 +-
 Jint.Tests.Test262/Test262Test.cs             |    1 -
 ...odulePreparationTests.ScriptPreparation.cs |    8 +-
 Jint/Engine.Ast.cs                            |    3 +
 Jint/Engine.Defaults.cs                       |   88 +-
 Jint/Native/Iterator/IteratorInstance.cs      |    2 +-
 Jint/Native/JsRegExp.cs                       |   32 +-
 Jint/Native/RegExp/RegExpConstructor.cs       |  673 +++-
 Jint/Native/RegExp/RegExpPrototype.cs         |  223 +-
 Jint/ParsingOptions.cs                        |   79 +-
 Jint/PreparationOptions.cs                    |    8 +-
 .../Expressions/JintLiteralExpression.cs      |   54 +-
 Jint/Runtime/RegExp/JintRegExpEngine.cs       |  121 +
 Jint/Runtime/RegExp/JsRegExpConverter.cs      |  472 +++
 Jint/Runtime/RegExp/RegExpCompiler.cs         | 2832 +++++++++++++++++
 Jint/Runtime/RegExp/RegExpInterpreter.cs      | 1314 ++++++++
 Jint/Runtime/RegExp/RegExpMatchResult.cs      |   28 +
 Jint/Runtime/RegExp/RegExpOpcode.cs           |  146 +
 Jint/Runtime/RegExp/RegExpSyntaxException.cs  |   11 +
 Jint/Runtime/RegExp/Unicode/UnicodeData.cs    | 1636 ++++++++++
 .../RegExp/Unicode/UnicodeProperties.cs       |  783 +++++
 22 files changed, 8440 insertions(+), 137 deletions(-)
 create mode 100644 Jint/Runtime/RegExp/JintRegExpEngine.cs
 create mode 100644 Jint/Runtime/RegExp/JsRegExpConverter.cs
 create mode 100644 Jint/Runtime/RegExp/RegExpCompiler.cs
 create mode 100644 Jint/Runtime/RegExp/RegExpInterpreter.cs
 create mode 100644 Jint/Runtime/RegExp/RegExpMatchResult.cs
 create mode 100644 Jint/Runtime/RegExp/RegExpOpcode.cs
 create mode 100644 Jint/Runtime/RegExp/RegExpSyntaxException.cs
 create mode 100644 Jint/Runtime/RegExp/Unicode/UnicodeData.cs
 create mode 100644 Jint/Runtime/RegExp/Unicode/UnicodeProperties.cs

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 1ad2f23da8..db46280bc1 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -4,8 +4,8 @@
     <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
   </PropertyGroup>
   <ItemGroup>
-    <PackageVersion Include="Acornima" Version="1.3.2" />
-    <PackageVersion Include="Acornima.Extras" Version="1.3.2" />
+    <PackageVersion Include="Acornima" Version="1.4.0" />
+    <PackageVersion Include="Acornima.Extras" Version="1.4.0" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.15.8" />
     <PackageVersion Include="BenchmarkDotNet.TestAdapter" Version="0.13.12" />
     <PackageVersion Include="FluentAssertions" Version="[7.2.2]" />
diff --git a/Jint.Tests.Test262/Test262Harness.settings.json b/Jint.Tests.Test262/Test262Harness.settings.json
index 780a9ece46..b37710982d 100644
--- a/Jint.Tests.Test262/Test262Harness.settings.json
+++ b/Jint.Tests.Test262/Test262Harness.settings.json
@@ -7,8 +7,6 @@
   "ExcludedFeatures": [
     "import-defer",
     "import-text",
-    "regexp-unicode-property-escapes",
-    "regexp-v-flag",
     "source-phase-imports",
     "tail-call-optimization"
   ],
@@ -26,55 +24,6 @@
     // Currently quite impossible to detect if assignment target is CoverParenthesizedExpression
     "language/expressions/assignment/fn-name-lhs-cover.js",
 
-    // === REGEX EXCLUSIONS ===
-
-    // CharacterClassEscapes tests internally use v flag which is not supported
-    "built-ins/RegExp/CharacterClassEscapes/*.js",
-
-    // .NET regex engine: forward backreferences not supported in ECMAScript mode
-    "built-ins/RegExp/S15.10.2.11_A1_T5.js",
-    "built-ins/RegExp/S15.10.2.11_A1_T7.js",
-    "language/literals/regexp/named-groups/forward-reference.js",
-    "built-ins/RegExp/named-groups/non-unicode-references.js",
-    "built-ins/RegExp/named-groups/unicode-references.js",
-
-    // .NET regex engine: lookbehind backreference capture semantics differ from JS
-    "built-ins/RegExp/lookBehind/back-references-to-captures.js",
-    "built-ins/RegExp/lookBehind/mutual-recursive.js",
-
-    // .NET regex engine: nullable quantifier and lookahead capture group semantics differ
-    "built-ins/RegExp/nullable-quantifier.js",
-    "built-ins/RegExp/lookahead-quantifier-match-groups.js",
-
-    // .NET regex engine: scoped regexp modifiers don't fully match ECMAScript boundary and multiline semantics
-    "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-b.js",
-    "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-lower-w.js",
-    "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-b.js",
-    "built-ins/RegExp/regexp-modifiers/add-ignoreCase-affects-slash-upper-w.js",
-    "built-ins/RegExp/regexp-modifiers/add-multiline.js",
-    "built-ins/RegExp/regexp-modifiers/remove-multiline-does-not-affect-dotAll-flag.js",
-
-    // .NET regex engine: complex quantifier capture group tracking differs
-    "built-ins/RegExp/S15.10.2.5_A1_T4.js",
-    "built-ins/RegExp/prototype/exec/S15.10.6.2_A1_T6.js",
-
-    // .NET regex engine: Unicode case folding tables differ from ECMAScript CaseFolding.txt
-    "language/literals/regexp/u-case-mapping.js",
-    "built-ins/RegExp/unicode_full_case_folding.js",
-
-    // .NET regex engine: quantifier values exceeding int.MaxValue
-    "built-ins/RegExp/quantifier-integer-limit.js",
-
-    // .NET regex engine: quantified groups with alternation retain captures from previous iterations
-    // (JavaScript resets non-participating groups per iteration, .NET does not)
-    "built-ins/RegExp/named-groups/duplicate-names-exec.js",
-    "built-ins/RegExp/named-groups/duplicate-names-match.js",
-    "built-ins/RegExp/named-groups/duplicate-names-test.js",
-    "built-ins/RegExp/prototype/exec/duplicate-named-groups-properties.js",
-    "built-ins/RegExp/prototype/exec/duplicate-named-indices-groups-properties.js",
-    "built-ins/String/prototype/match/duplicate-named-groups-properties.js",
-    "built-ins/String/prototype/match/duplicate-named-indices-groups-properties.js",
-
     // requires investigation how to process complex function name evaluation for property
     "built-ins/Function/prototype/toString/method-computed-property-name.js",
 
@@ -355,13 +304,7 @@
     "intl402/Temporal/ZonedDateTime/prototype/with/leap-year-hebrew.js",
     "intl402/Temporal/ZonedDateTime/prototype/withCalendar/extreme-dates.js",
     "intl402/Temporal/ZonedDateTime/prototype/year/arithmetic-year.js",
-    "intl402/Temporal/ZonedDateTime/prototype/year/epoch-year.js",
-
-    // === ANNEX B EXCLUSIONS ===
-
-    // Acornima parser/RegExp limitation: malformed named groups in non-unicode mode
-    // Per B.1.2, non-unicode RegExp should accept some malformed named group syntax
-    "annexB/built-ins/RegExp/named-groups/non-unicode-malformed.js"
+    "intl402/Temporal/ZonedDateTime/prototype/year/epoch-year.js"
 
   ]
 }
diff --git a/Jint.Tests.Test262/Test262Test.cs b/Jint.Tests.Test262/Test262Test.cs
index 1154d695c8..d55fea1f05 100644
--- a/Jint.Tests.Test262/Test262Test.cs
+++ b/Jint.Tests.Test262/Test262Test.cs
@@ -1,7 +1,6 @@
 #nullable enable
 
 using Jint.Native;
-using Jint.Native.Error;
 using Jint.Native.Object;
 using Jint.Runtime;
 using Jint.Runtime.Interop;
diff --git a/Jint.Tests/Runtime/ScriptModulePreparationTests.ScriptPreparation.cs b/Jint.Tests/Runtime/ScriptModulePreparationTests.ScriptPreparation.cs
index fcb15cadfe..6e65f93230 100644
--- a/Jint.Tests/Runtime/ScriptModulePreparationTests.ScriptPreparation.cs
+++ b/Jint.Tests/Runtime/ScriptModulePreparationTests.ScriptPreparation.cs
@@ -22,8 +22,12 @@ public void CanPreCompileRegex()
         var declaration = Assert.IsType<VariableDeclaration>(script.Program.Body[0]);
         var init = Assert.IsType<RegExpLiteral>(declaration.Declarations[0].Init);
 
-        init.Value.ToString().Should().Be("[cgt]");
-        (init.Value.Options & RegexOptions.Compiled).Should().Be(RegexOptions.Compiled);
+        // Regex is pre-compiled during preparation with Compiled flag
+        var regex = init.ParseResult.Regex;
+        regex.Should().NotBeNull();
+        (regex!.Options & RegexOptions.Compiled).Should().Be(RegexOptions.Compiled);
+
+        // Prepared script executes correctly
         new Engine().Evaluate(script).AsNumber().Should().Be(1);
     }
 
diff --git a/Jint/Engine.Ast.cs b/Jint/Engine.Ast.cs
index 13075da536..3e843dad4e 100644
--- a/Jint/Engine.Ast.cs
+++ b/Jint/Engine.Ast.cs
@@ -29,6 +29,7 @@ public static Prepared<Script> PrepareScript(string code, string? source = null,
             Script preparedScript;
             var sourceOffset = options.ParsingOptions.SourceOffset;
             var padding = AcornimaExtensions.CreateSourceOffsetPadding(sourceOffset);
+
             if (padding.Length > 0)
             {
                 var paddedCode = padding + code;
@@ -38,6 +39,7 @@ public static Prepared<Script> PrepareScript(string code, string? source = null,
             {
                 preparedScript = parser.ParseScript(code, source, strict);
             }
+
             return new Prepared<Script>(preparedScript, parserOptions);
         }
         catch (Exception e)
@@ -64,6 +66,7 @@ public static Prepared<Module> PrepareModule(string code, string? source = null,
         try
         {
             var preparedModule = parser.ParseModule(code, source);
+
             return new Prepared<Module>(preparedModule, parserOptions);
         }
         catch (Exception e)
diff --git a/Jint/Engine.Defaults.cs b/Jint/Engine.Defaults.cs
index 1517bde464..fdb99ef390 100644
--- a/Jint/Engine.Defaults.cs
+++ b/Jint/Engine.Defaults.cs
@@ -1,17 +1,93 @@
+using Jint.Native.RegExp;
+using Jint.Runtime.RegExp;
+
 namespace Jint;
 
 public partial class Engine
 {
     internal const bool FoldConstantsOnPrepareByDefault = true;
 
+    private static readonly TimeSpan DefaultPrepareRegexTimeout = TimeSpan.FromSeconds(10);
+
+    /// <summary>
+    /// OnRegExp callback that validates regex syntax at parse time without converting.
+    /// Conversion is done at runtime in RegExpInitialize with fallback to the custom engine.
+    /// </summary>
+    internal static readonly OnRegExpHandler ValidateRegExpHandler = static (in RegExpParsingContext ctx) =>
+    {
+        ctx.Validate();
+        return RegExpParseResult.ForSuccess();
+    };
+
+    /// <summary>
+    /// OnRegExp callback that validates and converts regex at parse time (interpreted .NET Regex).
+    /// Used during script/module preparation when CompileRegex is false.
+    /// </summary>
+    internal static readonly OnRegExpHandler ConvertRegExpHandler = static (in RegExpParsingContext ctx) =>
+    {
+        ctx.Validate();
+        // Skip pre-compilation for patterns that need the custom QuickJS engine at runtime
+        if (!RegExpConstructor.NeedCustomEngine(ctx.Pattern, ctx.Flags)
+            && JsRegExpConverter.TryConvert(ctx.Pattern, ctx.Flags, DefaultPrepareRegexTimeout, out var regex, out var groupCount))
+        {
+            return RegExpParseResult.ForSuccess(regex, groupCount);
+        }
+
+        return RegExpParseResult.ForSuccess();
+    };
+
+    /// <summary>
+    /// OnRegExp callback that validates and converts regex at parse time (compiled .NET Regex).
+    /// Used during script/module preparation when CompileRegex is true (default for preparation).
+    /// </summary>
+    internal static readonly OnRegExpHandler CompileRegExpHandler = static (in RegExpParsingContext ctx) =>
+    {
+        ctx.Validate();
+        // Skip pre-compilation for patterns that need the custom QuickJS engine at runtime
+        if (!RegExpConstructor.NeedCustomEngine(ctx.Pattern, ctx.Flags)
+            && JsRegExpConverter.TryConvert(ctx.Pattern, ctx.Flags, DefaultPrepareRegexTimeout, out var regex, out var groupCount, compiled: true))
+        {
+            return RegExpParseResult.ForSuccess(regex, groupCount);
+        }
+
+        return RegExpParseResult.ForSuccess();
+    };
+
+    /// <summary>
+    /// Creates an OnRegExp handler with a caller-specified timeout (interpreted .NET Regex).
+    /// </summary>
+    internal static OnRegExpHandler CreateConvertRegExpHandler(TimeSpan timeout) => (in RegExpParsingContext ctx) =>
+    {
+        ctx.Validate();
+        if (!RegExpConstructor.NeedCustomEngine(ctx.Pattern, ctx.Flags)
+            && JsRegExpConverter.TryConvert(ctx.Pattern, ctx.Flags, timeout, out var regex, out var groupCount))
+        {
+            return RegExpParseResult.ForSuccess(regex, groupCount);
+        }
+
+        return RegExpParseResult.ForSuccess();
+    };
+
+    /// <summary>
+    /// Creates an OnRegExp handler with a caller-specified timeout (compiled .NET Regex).
+    /// </summary>
+    internal static OnRegExpHandler CreateCompileRegExpHandler(TimeSpan timeout) => (in RegExpParsingContext ctx) =>
+    {
+        ctx.Validate();
+        if (!RegExpConstructor.NeedCustomEngine(ctx.Pattern, ctx.Flags)
+            && JsRegExpConverter.TryConvert(ctx.Pattern, ctx.Flags, timeout, out var regex, out var groupCount, compiled: true))
+        {
+            return RegExpParseResult.ForSuccess(regex, groupCount);
+        }
+
+        return RegExpParseResult.ForSuccess();
+    };
+
     internal static readonly ParserOptions BaseParserOptions = ParserOptions.Default with
     {
-        EcmaVersion = EcmaVersion.ES2023,
-        ExperimentalESFeatures = ExperimentalESFeatures.ImportAttributes
-                                 | ExperimentalESFeatures.RegExpDuplicateNamedCapturingGroups
-                                 | ExperimentalESFeatures.RegExpModifiers
-                                 | ExperimentalESFeatures.ExplicitResourceManagement
-                                 | ExperimentalESFeatures.Decorators,
+        EcmaVersion = EcmaVersion.ES2026,
+        ExperimentalESFeatures = ExperimentalESFeatures.Decorators,
+        OnRegExp = ValidateRegExpHandler,
         Tolerant = false,
     };
 }
diff --git a/Jint/Native/Iterator/IteratorInstance.cs b/Jint/Native/Iterator/IteratorInstance.cs
index afe68e6150..c410e60778 100644
--- a/Jint/Native/Iterator/IteratorInstance.cs
+++ b/Jint/Native/Iterator/IteratorInstance.cs
@@ -227,7 +227,7 @@ public override bool TryIteratorStep(out ObjectInstance nextItem)
                 if (macthStr == "")
                 {
                     var thisIndex = TypeConverter.ToLength(_iteratingRegExp.Get(JsRegExp.PropertyLastIndex));
-                    var nextIndex = thisIndex + 1;
+                    var nextIndex = RegExpPrototype.AdvanceStringIndex(_s, thisIndex, _unicode);
                     _iteratingRegExp.Set(JsRegExp.PropertyLastIndex, nextIndex, true);
                 }
             }
diff --git a/Jint/Native/JsRegExp.cs b/Jint/Native/JsRegExp.cs
index 4245e3f1e0..bb36da58c8 100644
--- a/Jint/Native/JsRegExp.cs
+++ b/Jint/Native/JsRegExp.cs
@@ -3,6 +3,7 @@
 using Jint.Native.RegExp;
 using Jint.Runtime;
 using Jint.Runtime.Descriptors;
+using Jint.Runtime.RegExp;
 
 namespace Jint.Native;
 
@@ -24,6 +25,12 @@ public JsRegExp(Engine engine)
     public Regex Value { get; set; } = null!;
     public string Source { get; set; }
 
+    /// <summary>
+    /// Custom regex engine used when .NET Regex cannot handle the pattern.
+    /// When set, this takes priority over <see cref="Value"/>.
+    /// </summary>
+    internal JintRegExpEngine? CustomEngine { get; set; }
+
     public string Flags
     {
         get => _flags;
@@ -37,6 +44,7 @@ public string Flags
             IgnoreCase = false;
             Multiline = false;
             Sticky = false;
+            Unicode = false;
             FullUnicode = false;
             UnicodeSets = false;
             foreach (var c in _flags)
@@ -62,17 +70,33 @@ public string Flags
                         Sticky = true;
                         break;
                     case 'u':
+                        Unicode = true;
                         FullUnicode = true;
                         break;
                     case 'v':
                         UnicodeSets = true;
+                        FullUnicode = true; // v-flag implies unicode semantics
                         break;
                 }
             }
         }
     }
 
-    public RegExpParseResult ParseResult { get; set; }
+    /// <summary>
+    /// JS group count (including group 0 for full match) from Jint's converter.
+    /// 0 means not set — fall back to .NET Regex's own group count.
+    /// </summary>
+    internal int ConvertedGroupCount { get; set; }
+
+    /// <summary>
+    /// Provides backward-compatible access to the regex parse result.
+    /// </summary>
+    [Obsolete("The ParseResult property is no longer populated. Use Value to access the .NET Regex instance directly.")]
+    public RegExpParseResult ParseResult
+    {
+        get => UsesDotNetEngine && Value is not null ? RegExpParseResult.ForSuccess(Value) : default;
+        set { /* no-op for backward compatibility */ }
+    }
 
     public bool DotAll { get; private set; }
     public bool Global { get; private set; }
@@ -80,11 +104,17 @@ public string Flags
     public bool IgnoreCase { get; private set; }
     public bool Multiline { get; private set; }
     public bool Sticky { get; private set; }
+    /// <summary>Whether the 'u' flag was explicitly set (for the unicode accessor).</summary>
+    public bool Unicode { get; private set; }
+    /// <summary>Whether unicode semantics apply (true for both 'u' and 'v' flags).</summary>
     public bool FullUnicode { get; private set; }
     public bool UnicodeSets { get; private set; }
 
     internal bool HasDefaultRegExpExec => Properties == null && Prototype is RegExpPrototype { HasDefaultExec: true };
 
+    /// <summary>Whether this regex uses the .NET Regex engine (not the custom engine).</summary>
+    internal bool UsesDotNetEngine => CustomEngine is null;
+
     public override PropertyDescriptor GetOwnProperty(JsValue property)
     {
         if (PropertyLastIndex.Equals(property))
diff --git a/Jint/Native/RegExp/RegExpConstructor.cs b/Jint/Native/RegExp/RegExpConstructor.cs
index d1a7c922d1..30d70d0661 100644
--- a/Jint/Native/RegExp/RegExpConstructor.cs
+++ b/Jint/Native/RegExp/RegExpConstructor.cs
@@ -1,17 +1,20 @@
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Threading;
 using Jint.Native.Function;
 using Jint.Native.Object;
 using Jint.Native.Symbol;
 using Jint.Runtime;
 using Jint.Runtime.Descriptors;
 using Jint.Runtime.Interop;
+using Jint.Runtime.RegExp;
 
 namespace Jint.Native.RegExp;
 
 public sealed class RegExpConstructor : Constructor
 {
     private static readonly JsString _functionName = new JsString("RegExp");
+    private static readonly Regex DummyRegex = new("(?:)", RegexOptions.None, TimeSpan.FromSeconds(1));
 
     // B.2.4 RegExp Legacy Static Properties
     internal string _legacyInput = "";
@@ -442,24 +445,30 @@ internal JsRegExp RegExpInitialize(JsRegExp r, JsValue pattern, JsValue flags, b
 
         var f = flags.IsUndefined() ? "" : TypeConverter.ToString(flags);
 
-        var parserOptions = _engine.GetActiveParserOptions();
-        try
-        {
-            var regExpParseResult = Tokenizer.AdaptRegExp(p, f, compiled: false, parserOptions.RegexTimeout,
-                ecmaVersion: parserOptions.EcmaVersion,
-                experimentalESFeatures: parserOptions.ExperimentalESFeatures);
-
-            if (!regExpParseResult.Success)
-            {
-                Throw.SyntaxError(_realm, $"Unsupported regular expression. {regExpParseResult.ConversionError!.Description}");
-            }
+        // Validate flags before attempting compilation - invalid flags should always be a SyntaxError
+        ValidateFlags(f);
 
-            r.Value = regExpParseResult.Regex!;
-            r.ParseResult = regExpParseResult;
+        // Two-tier regex compilation:
+        // 1. Patterns with known .NET divergences → custom QuickJS bytecode engine (guaranteed correct)
+        // 2. Jint's lightweight converter rewrites JS escapes to .NET standard mode equivalents
+        //    Falls back to custom engine if conversion fails.
+        if (NeedCustomEngine(p, f))
+        {
+            TryCompileWithCustomEngine(r, p, f);
         }
-        catch (Exception ex)
+        else
         {
-            Throw.SyntaxError(_realm, ex.Message);
+            var regexTimeout = _engine.Options.Constraints.RegexTimeout;
+            if (JsRegExpConverter.TryConvert(p, f, regexTimeout, out var regex, out var groupCount))
+            {
+                r.Value = regex;
+                r.ConvertedGroupCount = groupCount;
+                r.CustomEngine = null;
+            }
+            else
+            {
+                TryCompileWithCustomEngine(r, p, f);
+            }
         }
 
         r.Flags = f;
@@ -479,6 +488,606 @@ internal JsRegExp RegExpInitialize(JsRegExp r, JsValue pattern, JsValue flags, b
         return r;
     }
 
+    /// <summary>
+    /// Validate regex flags per ECMAScript spec: only "dgimsuvy" allowed, no duplicates,
+    /// u and v are mutually exclusive.
+    /// </summary>
+    private void ValidateFlags(string flags)
+    {
+        var seen = 0;
+        foreach (var c in flags)
+        {
+            var bit = c switch
+            {
+                'd' => 1,
+                'g' => 2,
+                'i' => 4,
+                'm' => 8,
+                's' => 16,
+                'u' => 32,
+                'v' => 64,
+                'y' => 128,
+                _ => -1,
+            };
+
+            if (bit < 0)
+            {
+                Throw.SyntaxError(_realm, $"Invalid regular expression flags: {flags}");
+            }
+
+            if ((seen & bit) != 0)
+            {
+                Throw.SyntaxError(_realm, $"Invalid regular expression flags: {flags}");
+            }
+
+            seen |= bit;
+        }
+
+        // u and v are mutually exclusive
+        if ((seen & 32) != 0 && (seen & 64) != 0)
+        {
+            Throw.SyntaxError(_realm, $"Invalid regular expression flags: {flags}");
+        }
+    }
+
+    /// <summary>
+    /// Detect patterns where .NET Regex produces semantically incorrect results
+    /// compared to ECMAScript specification. These patterns need the custom engine.
+    /// </summary>
+    internal static bool NeedCustomEngine(string pattern, string flags)
+    {
+        // Unicode modes: JsRegExpConverter always rejects these (it uses standard mode,
+        // not ECMAScript mode). Route directly to custom engine to avoid the wasted
+        // TryConvert call at both preparation and runtime.
+        if (flags.Contains('u') || flags.Contains('v'))
+        {
+            return true;
+        }
+
+        // Named groups: JsRegExpConverter rejects all named groups (?<name>...) because
+        // .NET group numbering semantics differ. Route directly to avoid wasted TryConvert.
+        if (pattern.Contains("(?<") && HasNamedGroup(pattern))
+        {
+            return true;
+        }
+
+        // Scoped regexp modifiers (?i:...), (?-m:...), etc.
+        // .NET gets \b/\w semantics wrong with (?i:...) + /u flag
+        // (doesn't include U+017F long-s and U+212A kelvin sign)
+        if (HasScopedModifiers(pattern))
+        {
+            return true;
+        }
+
+        // Forward backreference: \N appears before the Nth capture group
+        // e.g. \1(a) - .NET ECMAScript mode doesn't support this
+        if (HasForwardBackReference(pattern))
+        {
+            return true;
+        }
+
+        // Forward named backreference: \k<name> appears before (?<name>...)
+        if (HasForwardNamedBackReference(pattern))
+        {
+            return true;
+        }
+
+        // Lookbehind with backreferences: (?<=\1(\w)) or (?<!...)
+        // .NET lookbehind capture semantics differ from JS
+        if ((pattern.Contains("(?<=") || pattern.Contains("(?<!")) && HasBackReferenceInLookbehind(pattern))
+        {
+            return true;
+        }
+
+        // Nullable quantifier around capturing groups: .NET RepeatMatcher doesn't
+        // implement step 2.b (discard zero-width optional iterations).
+        // E.g., /(a?b??)*/ or /(?:(?=(abc)))?a/ — .NET gets captures wrong.
+        if (HasNullableQuantifierCapture(pattern))
+        {
+            return true;
+        }
+
+        // Case-insensitive with non-ASCII characters: .NET IgnoreCase applies broader
+        // Unicode case folding than ES spec (e.g. U+212A KELVIN SIGN matches 'K',
+        // U+017F LONG S matches 's'). In non-unicode mode, ES spec Canonicalize uses
+        // toUpperCase only, not Unicode case folding. This applies to both literal
+        // non-ASCII characters and \uXXXX escape sequences for non-ASCII code points.
+        if (flags.Contains('i') && HasNonAsciiContent(pattern))
+        {
+            return true;
+        }
+
+        // Duplicate named groups in alternation: (?<x>a)|(?<x>b)
+        // .NET doesn't support duplicate named groups in ECMAScript mode.
+        if (HasDuplicateNamedGroups(pattern))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Detect \p{...} or \P{...} unicode property escapes in the pattern.
+    /// </summary>
+    private static bool HasUnicodePropertyEscape(string pattern)
+    {
+        for (int i = 0; i < pattern.Length - 2; i++)
+        {
+            if (pattern[i] == '\\' && (pattern[i + 1] == 'p' || pattern[i + 1] == 'P') &&
+                i + 2 < pattern.Length && pattern[i + 2] == '{')
+            {
+                return true;
+            }
+
+            if (pattern[i] == '\\')
+            {
+                i++;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Detect nullable quantifier (min=0) around groups that contain capturing sub-groups.
+    /// .NET Regex doesn't implement ES spec RepeatMatcher step 2.b correctly:
+    /// after an optional iteration that matches the empty string, JS discards the iteration
+    /// (clearing its captures), while .NET retains them.
+    /// Only routes to the custom engine when the nullable-quantified group actually contains
+    /// a capturing group — non-capturing groups like (?:foo)? are safe for .NET.
+    /// </summary>
+    private static bool HasNullableQuantifierCapture(string pattern)
+    {
+        // Stack tracks group types: true = group contains a capture (is or contains a capturing group)
+        var groupStack = new List<bool>(8);
+        var inCharClass = false;
+
+        for (int i = 0; i < pattern.Length; i++)
+        {
+            var ch = pattern[i];
+
+            if (ch == '\\')
+            {
+                i++; // skip escaped char
+                continue;
+            }
+
+            if (inCharClass)
+            {
+                if (ch == ']')
+                {
+                    inCharClass = false;
+                }
+                continue;
+            }
+
+            switch (ch)
+            {
+                case '[':
+                    inCharClass = true;
+                    break;
+
+                case '(':
+                    if (i + 1 < pattern.Length && pattern[i + 1] == '?')
+                    {
+                        // Non-capturing group (?:...), lookahead (?=/?!), lookbehind (?<=/<!), etc.
+                        groupStack.Add(false);
+                    }
+                    else
+                    {
+                        // Capturing group — mark this level as containing a capture
+                        groupStack.Add(true);
+                    }
+                    break;
+
+                case ')':
+                    if (groupStack.Count > 0)
+                    {
+                        bool hasCapture = groupStack[groupStack.Count - 1];
+                        groupStack.RemoveAt(groupStack.Count - 1);
+
+                        // Check for nullable quantifier after this group close
+                        if (hasCapture && i + 1 < pattern.Length)
+                        {
+                            char next = pattern[i + 1];
+                            if (next == '?' || next == '*')
+                            {
+                                return true;
+                            }
+
+                            if (next == '{' && i + 2 < pattern.Length && pattern[i + 2] == '0')
+                            {
+                                return true;
+                            }
+                        }
+
+                        // Propagate capture flag to parent group
+                        if (hasCapture && groupStack.Count > 0)
+                        {
+                            groupStack[groupStack.Count - 1] = true;
+                        }
+                    }
+                    break;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Detect non-ASCII content in the pattern: either literal non-ASCII characters or
+    /// \uXXXX / \u{XXXX} hex escapes for non-ASCII code points (&gt;0x7F).
+    /// .NET IgnoreCase applies broader Unicode case folding than ES spec for these characters.
+    /// ASCII-range escapes like \u0041 work correctly in .NET and don't need the custom engine.
+    /// </summary>
+    private static bool HasNonAsciiContent(string pattern)
+    {
+        for (int i = 0; i < pattern.Length; i++)
+        {
+            if (pattern[i] == '\\' && i + 1 < pattern.Length)
+            {
+                if (pattern[i + 1] == 'u' && i + 2 < pattern.Length)
+                {
+                    if (pattern[i + 2] == '{')
+                    {
+                        // \u{XXXX} syntax — parse hex value
+                        int value = 0;
+                        int j = i + 3;
+                        while (j < pattern.Length && pattern[j] != '}')
+                        {
+                            int digit = HexDigitValue(pattern[j]);
+                            if (digit < 0) break;
+                            value = (value << 4) | digit;
+                            j++;
+                        }
+
+                        if (j < pattern.Length && pattern[j] == '}' && value > 0x7F)
+                        {
+                            return true;
+                        }
+
+                        i = j; // skip past parsed escape
+                    }
+                    else if (i + 5 < pattern.Length)
+                    {
+                        // \uXXXX syntax — parse 4 hex digits
+                        int d0 = HexDigitValue(pattern[i + 2]);
+                        int d1 = HexDigitValue(pattern[i + 3]);
+                        int d2 = HexDigitValue(pattern[i + 4]);
+                        int d3 = HexDigitValue(pattern[i + 5]);
+                        if (d0 >= 0 && d1 >= 0 && d2 >= 0 && d3 >= 0)
+                        {
+                            int value = (d0 << 12) | (d1 << 8) | (d2 << 4) | d3;
+                            if (value > 0x7F)
+                            {
+                                return true;
+                            }
+                        }
+
+                        i += 5; // skip past \uXXXX
+                    }
+                    else
+                    {
+                        i++; // skip escaped char
+                    }
+                }
+                else
+                {
+                    i++; // skip escaped char
+                }
+            }
+            else if (pattern[i] > 0x7F)
+            {
+                // Literal non-ASCII character in the pattern
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static int HexDigitValue(char c)
+    {
+        if (c >= '0' && c <= '9') return c - '0';
+        if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+        if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+        return -1;
+    }
+
+    /// <summary>
+    /// Detect scoped modifier groups: (?i:...), (?-m:...), (?ims-ims:...) etc.
+    /// </summary>
+    private static bool HasScopedModifiers(string pattern)
+    {
+        for (int i = 0; i < pattern.Length - 2; i++)
+        {
+            if (pattern[i] == '\\')
+            {
+                i++; // skip escaped char
+                continue;
+            }
+
+            if (pattern[i] == '(' && pattern[i + 1] == '?' &&
+                i + 2 < pattern.Length && pattern[i + 2] is 'i' or 'm' or 's' or '-')
+            {
+                // Distinguish from (?= (?! (?< (?:
+                // Modifier groups start with (?[ims-] and must contain ':'
+                int j = i + 2;
+                while (j < pattern.Length && pattern[j] is 'i' or 'm' or 's' or '-')
+                {
+                    j++;
+                }
+                if (j < pattern.Length && pattern[j] == ':')
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Detect named capturing groups (?&lt;name&gt;...), excluding lookbehind assertions (?&lt;=...) and (?&lt;!...).
+    /// </summary>
+    private static bool HasNamedGroup(string pattern)
+    {
+        for (int i = 0; i < pattern.Length - 2; i++)
+        {
+            if (pattern[i] == '\\')
+            {
+                i++; // skip escaped char
+                continue;
+            }
+
+            if (pattern[i] == '(' && pattern[i + 1] == '?' && pattern[i + 2] == '<'
+                && i + 3 < pattern.Length && pattern[i + 3] != '=' && pattern[i + 3] != '!')
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Detect forward named backreferences: \k&lt;name&gt; appearing before (?&lt;name&gt;...) is defined.
+    /// </summary>
+    private static bool HasForwardNamedBackReference(string pattern)
+    {
+        // First pass: collect all named group definitions and their positions
+        var groupPositions = new Dictionary<string, int>(StringComparer.Ordinal);
+        for (int i = 0; i < pattern.Length - 3; i++)
+        {
+            if (pattern[i] == '\\')
+            {
+                i++; // skip escaped char
+                continue;
+            }
+
+            if (pattern[i] == '(' && pattern[i + 1] == '?' && pattern[i + 2] == '<' &&
+                i + 3 < pattern.Length && pattern[i + 3] != '=' && pattern[i + 3] != '!')
+            {
+                // Found (?<name>
+                int nameStart = i + 3;
+                int nameEnd = pattern.IndexOf('>', nameStart);
+                if (nameEnd > nameStart)
+                {
+                    var name = pattern.Substring(nameStart, nameEnd - nameStart);
+                    if (!groupPositions.ContainsKey(name))
+                    {
+                        groupPositions[name] = i;
+                    }
+                }
+            }
+        }
+
+        if (groupPositions.Count == 0)
+        {
+            return false;
+        }
+
+        // Second pass: find \k<name> references that precede their group definition
+        for (int i = 0; i < pattern.Length - 3; i++)
+        {
+            if (pattern[i] == '\\' && pattern[i + 1] == 'k' && i + 2 < pattern.Length && pattern[i + 2] == '<')
+            {
+                int nameStart = i + 3;
+                int nameEnd = pattern.IndexOf('>', nameStart);
+                if (nameEnd > nameStart)
+                {
+                    var name = pattern.Substring(nameStart, nameEnd - nameStart);
+                    if (groupPositions.TryGetValue(name, out int groupPos) && i < groupPos)
+                    {
+                        return true;
+                    }
+                }
+            }
+            else if (pattern[i] == '\\')
+            {
+                i++; // skip escaped char
+            }
+        }
+
+        return false;
+    }
+
+    private static bool HasBackReferenceInLookbehind(string pattern)
+    {
+        // Check if there's a \N backreference inside a lookbehind group
+        int idx = 0;
+        while (true)
+        {
+            int lb = pattern.IndexOf("(?<", idx, StringComparison.Ordinal);
+            if (lb < 0) break;
+            if (lb + 3 < pattern.Length && (pattern[lb + 3] == '=' || pattern[lb + 3] == '!'))
+            {
+                // Found lookbehind - scan until its matching closing parenthesis
+                int depth = 1;
+                for (int j = lb + 4; j < pattern.Length; j++)
+                {
+                    if (pattern[j] == '\\' && j + 1 < pattern.Length)
+                    {
+                        if (pattern[j + 1] >= '1' && pattern[j + 1] <= '9')
+                        {
+                            return true;
+                        }
+
+                        j++; // skip escaped char
+                        continue;
+                    }
+
+                    if (pattern[j] == '(') depth++;
+                    else if (pattern[j] == ')')
+                    {
+                        if (--depth == 0) break;
+                    }
+                }
+            }
+            idx = lb + 3;
+        }
+        return false;
+    }
+
+    private static bool HasDuplicateNamedGroups(string pattern)
+    {
+        // Scan for (?<name>...) groups and check if any name appears more than once
+        var names = new HashSet<string>(StringComparer.Ordinal);
+        int i = 0;
+        while (i < pattern.Length - 3)
+        {
+            if (pattern[i] == '\\')
+            {
+                i += 2; // skip escaped char
+                continue;
+            }
+
+            if (pattern[i] == '(' && pattern[i + 1] == '?' && pattern[i + 2] == '<' &&
+                i + 3 < pattern.Length && pattern[i + 3] != '=' && pattern[i + 3] != '!')
+            {
+                // Found (?<name>
+                int nameStart = i + 3;
+                int nameEnd = pattern.IndexOf('>', nameStart);
+                if (nameEnd > nameStart)
+                {
+                    var name = pattern.Substring(nameStart, nameEnd - nameStart);
+                    if (!names.Add(name))
+                    {
+                        return true; // duplicate found
+                    }
+                }
+            }
+
+            i++;
+        }
+
+        return false;
+    }
+
+    private static bool HasForwardBackReference(string pattern)
+    {
+        // Check if pattern contains \N where N references a group not yet defined.
+        // Skips escaped chars and character classes to avoid false positives.
+        int groupCount = 0;
+        bool inCharClass = false;
+        for (int i = 0; i < pattern.Length; i++)
+        {
+            if (pattern[i] == '\\' && i + 1 < pattern.Length)
+            {
+                if (!inCharClass)
+                {
+                    char next = pattern[i + 1];
+                    if (next >= '1' && next <= '9')
+                    {
+                        // Parse the full decimal backreference number
+                        int refNum = 0;
+                        int j = i + 1;
+                        while (j < pattern.Length && pattern[j] >= '0' && pattern[j] <= '9')
+                        {
+                            refNum = refNum * 10 + (pattern[j] - '0');
+                            j++;
+                        }
+
+                        if (refNum > groupCount)
+                        {
+                            return true;
+                        }
+
+                        i = j - 1; // skip past parsed digits
+                        continue;
+                    }
+                }
+
+                i++; // skip escaped char
+                continue;
+            }
+
+            if (inCharClass)
+            {
+                if (pattern[i] == ']') inCharClass = false;
+                continue;
+            }
+
+            if (pattern[i] == '[')
+            {
+                inCharClass = true;
+            }
+            else if (pattern[i] == '(' && i + 1 < pattern.Length && pattern[i + 1] != '?')
+            {
+                groupCount++;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Attempt to compile the regex pattern using the custom Jint regex engine.
+    /// Falls back to SyntaxError if the custom engine also fails.
+    /// </summary>
+    private void TryCompileWithCustomEngine(JsRegExp r, string pattern, string flags)
+    {
+        try
+        {
+            var regExpFlags = RegExpFlags.None;
+            foreach (var c in flags)
+            {
+                regExpFlags |= c switch
+                {
+                    'g' => RegExpFlags.Global,
+                    'i' => RegExpFlags.IgnoreCase,
+                    'm' => RegExpFlags.Multiline,
+                    's' => RegExpFlags.DotAll,
+                    'u' => RegExpFlags.Unicode,
+                    'y' => RegExpFlags.Sticky,
+                    'd' => RegExpFlags.Indices,
+                    'v' => RegExpFlags.UnicodeSets,
+                    _ => RegExpFlags.None,
+                };
+            }
+
+            var regexTimeout = _engine.Options.Constraints.RegexTimeout;
+            using var cts = regexTimeout.TotalMilliseconds > 0 && regexTimeout != Timeout.InfiniteTimeSpan
+                ? new CancellationTokenSource(regexTimeout)
+                : null;
+
+            r.CustomEngine = JintRegExpEngine.Compile(pattern, regExpFlags, cts?.Token ?? default);
+            // Set Value to a dummy regex to avoid null reference in code paths that read it
+            // but won't actually use it (since UsesDotNetEngine will be false)
+            r.Value = DummyRegex;
+            r.ConvertedGroupCount = 0;
+        }
+        catch (OperationCanceledException)
+        {
+            throw new RegexMatchTimeoutException(string.Empty, pattern, _engine.Options.Constraints.RegexTimeout);
+        }
+        catch (RegExpSyntaxException ex)
+        {
+            Throw.SyntaxError(_realm, ex.Message);
+        }
+    }
+
     /// <summary>
     /// https://tc39.es/ecma262/#sec-regexpcreate
     /// RegExpCreate(P, F) - creates a new RegExp without calling IsRegExp on the pattern.
@@ -507,13 +1116,43 @@ private JsRegExp RegExpAlloc(JsValue newTarget)
         return r;
     }
 
-    public JsRegExp Construct(Regex regExp, string source, string flags, RegExpParseResult regExpParseResult = default)
+    /// <summary>
+    /// Construct a RegExp using the custom engine for patterns that .NET Regex cannot handle.
+    /// Called from regex literal evaluation when Acornima conversion fails.
+    /// </summary>
+    internal JsRegExp ConstructWithCustomEngine(string pattern, string flags)
+    {
+        var r = RegExpAlloc(this);
+        ValidateFlags(flags);
+        TryCompileWithCustomEngine(r, pattern, flags);
+        r.Flags = flags;
+        r.Source = pattern;
+        RegExpInitialize(r);
+        return r;
+    }
+
+    /// <summary>
+    /// Construct a RegExp reusing a pre-compiled custom engine (avoids re-compilation of bytecode).
+    /// </summary>
+    internal JsRegExp Construct(JintRegExpEngine customEngine, string source, string flags)
+    {
+        var r = RegExpAlloc(this);
+        r.CustomEngine = customEngine;
+        r.Value = DummyRegex;
+        r.ConvertedGroupCount = 0;
+        r.Source = source;
+        r.Flags = flags;
+        RegExpInitialize(r);
+        return r;
+    }
+
+    public JsRegExp Construct(Regex regExp, string source, string flags)
     {
         var r = RegExpAlloc(this);
         r.Value = regExp;
         r.Source = source;
         r.Flags = flags;
-        r.ParseResult = regExpParseResult;
+        r.ConvertedGroupCount = 0; // user-provided Regex — use .NET's own group methods
 
         RegExpInitialize(r);
 
diff --git a/Jint/Native/RegExp/RegExpPrototype.cs b/Jint/Native/RegExp/RegExpPrototype.cs
index 5e0e96481d..e55ecc29f7 100644
--- a/Jint/Native/RegExp/RegExpPrototype.cs
+++ b/Jint/Native/RegExp/RegExpPrototype.cs
@@ -2,6 +2,7 @@
 
 using System.Text;
 using System.Text.RegularExpressions;
+using System.Threading;
 using Jint.Native.Number;
 using Jint.Native.Object;
 using Jint.Native.String;
@@ -9,6 +10,7 @@
 using Jint.Runtime;
 using Jint.Runtime.Descriptors;
 using Jint.Runtime.Interop;
+using Jint.Runtime.RegExp;
 
 namespace Jint.Native.RegExp;
 
@@ -86,7 +88,7 @@ GetSetPropertyDescriptor CreateGetAccessorDescriptor(string name, Func<JsRegExp,
             ["multiline"] = CreateGetAccessorDescriptor("get multiline", static r => r.Multiline),
             ["source"] = new GetSetPropertyDescriptor(get: new ClrFunction(Engine, "get source", Source, 0, lengthFlags), set: Undefined, flags: PropertyFlag.Configurable),
             ["sticky"] = CreateGetAccessorDescriptor("get sticky", static r => r.Sticky),
-            ["unicode"] = CreateGetAccessorDescriptor("get unicode", static r => r.FullUnicode),
+            ["unicode"] = CreateGetAccessorDescriptor("get unicode", static r => r.Unicode),
             ["unicodeSets"] = CreateGetAccessorDescriptor("get unicodeSets", static r => r.UnicodeSets)
         };
         SetProperties(properties);
@@ -157,16 +159,17 @@ private JsValue Replace(JsValue thisObject, JsCallArguments arguments)
 
         if (global)
         {
-            fullUnicode = flags.Contains('u');
+            fullUnicode = flags.Contains('u') || flags.Contains('v');
             rx.Set(JsRegExp.PropertyLastIndex, 0, true);
         }
 
-        // check if we can access fast path
+        // check if we can access fast path (only for .NET Regex engine)
         // Derive sticky from already-read flags string to avoid extra observable property access
         if (!fullUnicode
             && !mayHaveNamedCaptures
             && !flags.Contains('y')
-            && rx is JsRegExp rei && rei.HasDefaultRegExpExec)
+            && rx is JsRegExp rei && rei.HasDefaultRegExpExec
+            && rei.UsesDotNetEngine)
         {
             var count = global ? int.MaxValue : 1;
 
@@ -460,7 +463,7 @@ private JsValue Split(JsValue thisObject, JsCallArguments arguments)
         var limit = arguments.At(1);
         var c = SpeciesConstructor(rx, _realm.Intrinsics.RegExp);
         var flags = TypeConverter.ToJsString(rx.Get(PropertyFlags));
-        var unicodeMatching = flags.Contains('u');
+        var unicodeMatching = flags.Contains('u') || flags.Contains('v');
         var newFlags = flags.Contains('y') ? flags : new JsString(flags.ToString() + 'y');
         var splitter = Construct(c, [
             rx,
@@ -487,7 +490,7 @@ private JsValue Split(JsValue thisObject, JsCallArguments arguments)
             return a;
         }
 
-        if (!unicodeMatching && splitter is JsRegExp R && R.HasDefaultRegExpExec)
+        if (!unicodeMatching && splitter is JsRegExp R && R.HasDefaultRegExpExec && R.UsesDotNetEngine)
         {
             // we can take faster path
 
@@ -635,8 +638,8 @@ private JsValue Test(JsValue thisObject, JsCallArguments arguments)
         var r = AssertThisIsObjectInstance(thisObject, "RegExp.prototype.test");
         var s = TypeConverter.ToString(arguments.At(0));
 
-        // check couple fast paths
-        if (r is JsRegExp R && !R.FullUnicode)
+        // check couple fast paths (only for .NET Regex engine)
+        if (r is JsRegExp R && !R.FullUnicode && R.UsesDotNetEngine)
         {
             if (!R.Sticky && !R.Global)
             {
@@ -708,14 +711,15 @@ private JsValue Match(JsValue thisObject, JsCallArguments arguments)
             return RegExpExec(rx, s);
         }
 
-        var fullUnicode = flags.Contains('u');
+        var fullUnicode = flags.Contains('u') || flags.Contains('v');
         rx.Set(JsRegExp.PropertyLastIndex, JsNumber.PositiveZero, true);
 
         if (!fullUnicode
             && rx is JsRegExp rei
-            && rei.HasDefaultRegExpExec)
+            && rei.HasDefaultRegExpExec
+            && rei.UsesDotNetEngine)
         {
-            // fast path
+            // fast path (only for .NET Regex engine)
             var a = _realm.Intrinsics.Array.ArrayCreate(0);
 
             if (rei.Sticky)
@@ -805,12 +809,12 @@ private JsValue MatchAll(JsValue thisObject, JsCallArguments arguments)
         matcher.Set(JsRegExp.PropertyLastIndex, lastIndex, true);
 
         var global = flags.Contains('g');
-        var fullUnicode = flags.Contains('u');
+        var fullUnicode = flags.Contains('u') || flags.Contains('v');
 
         return _realm.Intrinsics.RegExpStringIteratorPrototype.Construct(matcher, s, global, fullUnicode);
     }
 
-    private static ulong AdvanceStringIndex(string s, ulong index, bool unicode)
+    internal static ulong AdvanceStringIndex(string s, ulong index, bool unicode)
     {
         if (!unicode || index + 1 >= (ulong) s.Length)
         {
@@ -887,6 +891,12 @@ private static JsValue RegExpBuiltinExec(JsRegExp R, string s)
             return array;
         }
 
+        // Use custom engine when .NET Regex cannot handle the pattern
+        if (!R.UsesDotNetEngine)
+        {
+            return CustomEngineBuiltinExec(R, s, lastIndex, global, sticky);
+        }
+
         var matcher = R.Value;
         var fullUnicode = R.FullUnicode;
         var hasIndices = R.Indices;
@@ -954,6 +964,183 @@ private static JsValue RegExpBuiltinExec(JsRegExp R, string s)
         return CreateReturnValueArray(R, match, s, fullUnicode, hasIndices);
     }
 
+    /// <summary>
+    /// RegExpBuiltinExec implementation for the custom regex engine.
+    /// </summary>
+    private static JsValue CustomEngineBuiltinExec(JsRegExp R, string s, ulong lastIndex, bool global, bool sticky)
+    {
+        var customEngine = R.CustomEngine!;
+        var hasIndices = R.Indices;
+        var length = (ulong) s.Length;
+
+        if (lastIndex > length)
+        {
+            if (global || sticky)
+            {
+                R.Set(JsRegExp.PropertyLastIndex, JsNumber.PositiveZero, true);
+            }
+
+            return Null;
+        }
+
+        var regexTimeout = R.Engine.Options.Constraints.RegexTimeout;
+        RegExpMatchResult result;
+        if (regexTimeout.TotalMilliseconds > 0 && regexTimeout != Timeout.InfiniteTimeSpan)
+        {
+            using var cts = new CancellationTokenSource(regexTimeout);
+            try
+            {
+                result = customEngine.Execute(s, (int) lastIndex, cts.Token);
+            }
+            catch (OperationCanceledException)
+            {
+                throw new RegexMatchTimeoutException(s, R.Source ?? "", regexTimeout);
+            }
+        }
+        else
+        {
+            result = customEngine.Execute(s, (int) lastIndex);
+        }
+        var success = result.Success && (!sticky || result.Index == (int) lastIndex);
+
+        if (!success)
+        {
+            if (global || sticky)
+            {
+                R.Set(JsRegExp.PropertyLastIndex, JsNumber.PositiveZero, true);
+            }
+
+            return Null;
+        }
+
+        var e = result.Index + result.Length;
+        if (global || sticky)
+        {
+            R.Set(JsRegExp.PropertyLastIndex, e, true);
+        }
+
+        return CreateReturnValueArrayFromCustom(R, result, s, hasIndices);
+    }
+
+    /// <summary>
+    /// Build the JS result array from a custom engine match result.
+    /// </summary>
+    private static JsArray CreateReturnValueArrayFromCustom(
+        JsRegExp rei,
+        in RegExpMatchResult result,
+        string s,
+        bool hasIndices)
+    {
+        var engine = rei.Engine;
+        var groups = result.Groups;
+        var actualGroupCount = groups?.Length ?? 1;
+        var array = engine.Realm.Intrinsics.Array.ArrayCreate((ulong) actualGroupCount);
+        array.CreateDataProperty(PropertyIndex, result.Index);
+        array.CreateDataProperty(PropertyInput, s);
+
+        ObjectInstance? jsGroups = null;
+        List<string?>? groupNames = null;
+        var indices = hasIndices ? new List<JsNumber[]?>(actualGroupCount) : null;
+
+        var hasAnyGroupName = false;
+
+        // Pre-initialize groups object
+        if (groups is not null)
+        {
+            for (uint i = 1; i < actualGroupCount; i++)
+            {
+                var groupName = groups[i].Name;
+                if (!string.IsNullOrWhiteSpace(groupName))
+                {
+                    hasAnyGroupName = true;
+                    jsGroups ??= OrdinaryObjectCreate(engine, null);
+                    if (!jsGroups.HasOwnProperty(groupName))
+                    {
+                        jsGroups.CreateDataPropertyOrThrow(groupName, Undefined);
+                    }
+                }
+
+                if (hasIndices)
+                {
+                    groupNames ??= [];
+                    groupNames.Add(groupName);
+                }
+            }
+        }
+
+        for (uint i = 0; i < actualGroupCount; i++)
+        {
+            var capture = groups?[(int) i];
+            JsValue capturedValue = Undefined;
+            if (capture?.Success == true)
+            {
+                capturedValue = capture.Value.Value;
+            }
+
+            if (hasIndices)
+            {
+                if (capture?.Success == true)
+                {
+                    indices!.Add([JsNumber.Create(capture.Value.Index), JsNumber.Create(capture.Value.Index + capture.Value.Length)]);
+                }
+                else
+                {
+                    indices!.Add(null);
+                }
+            }
+
+            if (i > 0)
+            {
+                var groupName = groups?[(int) i].Name;
+                if (!string.IsNullOrWhiteSpace(groupName) && capture?.Success == true)
+                {
+                    jsGroups!.CreateDataPropertyOrThrow(groupName, capturedValue);
+                }
+            }
+
+            array.SetIndexValue(i, capturedValue, updateLength: false);
+        }
+
+        array.CreateDataProperty(PropertyGroups, jsGroups ?? Undefined);
+
+        if (hasIndices)
+        {
+            var indicesArray = MakeMatchIndicesIndexPairArray(engine, s, indices!, groupNames, hasAnyGroupName);
+            array.CreateDataPropertyOrThrow("indices", indicesArray);
+        }
+
+        // B.2.4 Update legacy RegExp static properties
+        UpdateLegacyStaticPropertiesFromCustom(engine, result, s, actualGroupCount);
+
+        return array;
+    }
+
+    private static void UpdateLegacyStaticPropertiesFromCustom(Engine engine, in RegExpMatchResult result, string s, int actualGroupCount)
+    {
+        var constructor = engine.Realm.Intrinsics.RegExp;
+        constructor._legacyInput = s;
+        constructor._legacyLastMatch = result.Value;
+        constructor._legacyLeftContext = s.Substring(0, result.Index);
+        constructor._legacyRightContext = s.Substring(result.Index + result.Length);
+
+        var groups = result.Groups;
+        var lastParen = "";
+        for (var i = 0; i < 9; i++)
+        {
+            var groupIndex = i + 1;
+            if (groups is not null && groupIndex < actualGroupCount && groups[groupIndex].Success)
+            {
+                constructor._legacyParens[i] = groups[groupIndex].Value;
+                lastParen = groups[groupIndex].Value;
+            }
+            else
+            {
+                constructor._legacyParens[i] = "";
+            }
+        }
+        constructor._legacyLastParen = lastParen;
+    }
+
     private static JsArray CreateReturnValueArray(
         JsRegExp rei,
         Match match,
@@ -1130,7 +1317,7 @@ private static JsValue GetMatchIndexPair(Engine engine, string s, JsNumber[] mat
 
     private static int GetActualRegexGroupCount(JsRegExp rei, Match match)
     {
-        return rei.ParseResult.Success ? rei.ParseResult.ActualRegexGroupCount : match.Groups.Count;
+        return rei.ConvertedGroupCount > 0 ? rei.ConvertedGroupCount : match.Groups.Count;
     }
 
     private static string? GetRegexGroupName(JsRegExp rei, int index)
@@ -1139,14 +1326,10 @@ private static int GetActualRegexGroupCount(JsRegExp rei, Match match)
         {
             return null;
         }
-        var regex = rei.Value;
-        if (rei.ParseResult.Success)
-        {
-            return rei.ParseResult.GetRegexGroupName(index);
-        }
 
+        var regex = rei.Value;
         var groupNameFromNumber = regex.GroupNameFromNumber(index);
-        if (groupNameFromNumber.Length == 1 && groupNameFromNumber[0] == 48 + index)
+        if (string.Equals(groupNameFromNumber, index.ToString(System.Globalization.CultureInfo.InvariantCulture), StringComparison.Ordinal))
         {
             // regex defaults to index as group name when it's not a named group
             return null;
diff --git a/Jint/ParsingOptions.cs b/Jint/ParsingOptions.cs
index 8389cf5e1b..10347099bc 100644
--- a/Jint/ParsingOptions.cs
+++ b/Jint/ParsingOptions.cs
@@ -6,16 +6,17 @@ public interface IParsingOptions
 {
     /// <summary>
     /// Gets or sets whether to create compiled <see cref="Regex"/> instances when adapting regular expressions.
-    /// Defaults to <see langword="null"/>, which means that in the case of non-prepared scripts and modules
-    /// regular expressions will be interpreted, otherwise they will be compiled.
+    /// Defaults to <see langword="null"/>. When <see langword="true"/>, regex patterns are pre-compiled during
+    /// preparation using <see cref="RegexOptions.Compiled"/>. When <see langword="false"/>, interpreted .NET Regex
+    /// instances are created. When <see langword="null"/>, inherits from the base parser options.
+    /// Patterns that require the custom QuickJS engine are always deferred to runtime regardless of this setting.
     /// </summary>
     bool? CompileRegex { get; init; }
 
     /// <summary>
     /// Gets or sets the default timeout for created <see cref="Regex"/> instances.
     /// Defaults to <see langword="null"/>, which means that in the case of non-prepared scripts and modules
-    /// the <see cref="Options.ConstraintOptions.RegexTimeout"/> setting should apply,
-    /// otherwise the default of the <see cref="ParserOptions.RegexTimeout"/> setting (10 seconds).
+    /// the <see cref="Options.ConstraintOptions.RegexTimeout"/> setting should apply.
     /// </summary>
     /// <remarks>
     /// Please note that <see cref="Options.ConstraintOptions.RegexTimeout"/> setting will be ignored
@@ -36,7 +37,6 @@ public sealed record ScriptParsingOptions : IParsingOptions
     {
         AllowReturnOutsideFunction = true,
         AllowTopLevelUsing = true,
-        RegExpParseMode = RegExpParseMode.AdaptToInterpreted,
     };
 
     public static readonly ScriptParsingOptions Default = new();
@@ -65,29 +65,48 @@ public sealed record ScriptParsingOptions : IParsingOptions
     /// </summary>
     public Position SourceOffset { get; init; }
 
-    internal ParserOptions ApplyTo(ParserOptions parserOptions, RegExpParseMode defaultRegExpParseMode, TimeSpan defaultRegexTimeout) => parserOptions with
+    internal ParserOptions ApplyTo(ParserOptions parserOptions, TimeSpan? engineRegexTimeout = null) => parserOptions with
     {
         AllowReturnOutsideFunction = AllowReturnOutsideFunction,
-        RegExpParseMode = CompileRegex is null
-            ? defaultRegExpParseMode
-            : (CompileRegex.Value ? RegExpParseMode.AdaptToCompiled : RegExpParseMode.AdaptToInterpreted),
-        RegexTimeout = RegexTimeout ?? defaultRegexTimeout,
+        OnRegExp = GetOnRegExpHandler(parserOptions, engineRegexTimeout),
         Tolerant = Tolerant,
     };
 
+    private OnRegExpHandler? GetOnRegExpHandler(ParserOptions parserOptions, TimeSpan? engineRegexTimeout)
+    {
+        // Explicit RegexTimeout takes priority, then engine's configured timeout
+        var timeout = RegexTimeout ?? engineRegexTimeout;
+
+        if (timeout is { } t)
+        {
+            return CompileRegex switch
+            {
+                true => Engine.CreateCompileRegExpHandler(t),
+                false => Engine.CreateConvertRegExpHandler(t),
+                _ => parserOptions.OnRegExp,
+            };
+        }
+
+        return CompileRegex switch
+        {
+            true => Engine.CompileRegExpHandler,
+            false => Engine.ConvertRegExpHandler,
+            null => parserOptions.OnRegExp, // inherit from base (validate for scripts, compile for preparation)
+        };
+    }
+
     internal ParserOptions GetParserOptions() => ReferenceEquals(this, Default)
         ? _defaultParserOptions
-        : ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, _defaultParserOptions.RegexTimeout);
+        : ApplyTo(_defaultParserOptions);
 
     internal ParserOptions GetParserOptions(Options engineOptions)
-        => ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, engineOptions.Constraints.RegexTimeout);
+        => ApplyTo(_defaultParserOptions, engineOptions.Constraints.RegexTimeout);
 }
 
 public sealed record class ModuleParsingOptions : IParsingOptions
 {
     private static readonly ParserOptions _defaultParserOptions = Engine.BaseParserOptions with
     {
-        RegExpParseMode = RegExpParseMode.AdaptToInterpreted,
     };
 
     public static readonly ModuleParsingOptions Default = new();
@@ -101,19 +120,39 @@ public sealed record class ModuleParsingOptions : IParsingOptions
     /// <inheritdoc/>
     public bool Tolerant { get; init; } = _defaultParserOptions.Tolerant;
 
-    internal ParserOptions ApplyTo(ParserOptions baseOptions, RegExpParseMode defaultRegExpParseMode, TimeSpan defaultRegexTimeout) => baseOptions with
+    internal ParserOptions ApplyTo(ParserOptions baseOptions, TimeSpan? engineRegexTimeout = null) => baseOptions with
     {
-        RegExpParseMode = CompileRegex is null
-            ? defaultRegExpParseMode
-            : (CompileRegex.Value ? RegExpParseMode.AdaptToCompiled : RegExpParseMode.AdaptToInterpreted),
-        RegexTimeout = RegexTimeout ?? defaultRegexTimeout,
+        OnRegExp = GetOnRegExpHandler(baseOptions, engineRegexTimeout),
         Tolerant = Tolerant,
     };
 
+    private OnRegExpHandler? GetOnRegExpHandler(ParserOptions baseOptions, TimeSpan? engineRegexTimeout)
+    {
+        // Explicit RegexTimeout takes priority, then engine's configured timeout
+        var timeout = RegexTimeout ?? engineRegexTimeout;
+
+        if (timeout is { } t)
+        {
+            return CompileRegex switch
+            {
+                true => Engine.CreateCompileRegExpHandler(t),
+                false => Engine.CreateConvertRegExpHandler(t),
+                _ => baseOptions.OnRegExp,
+            };
+        }
+
+        return CompileRegex switch
+        {
+            true => Engine.CompileRegExpHandler,
+            false => Engine.ConvertRegExpHandler,
+            null => baseOptions.OnRegExp,
+        };
+    }
+
     internal ParserOptions GetParserOptions() => ReferenceEquals(this, Default)
         ? _defaultParserOptions
-        : ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, _defaultParserOptions.RegexTimeout);
+        : ApplyTo(_defaultParserOptions);
 
     internal ParserOptions GetParserOptions(Options engineOptions)
-        => ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, engineOptions.Constraints.RegexTimeout);
+        => ApplyTo(_defaultParserOptions, engineOptions.Constraints.RegexTimeout);
 }
diff --git a/Jint/PreparationOptions.cs b/Jint/PreparationOptions.cs
index b993f30cc0..174b4cfd93 100644
--- a/Jint/PreparationOptions.cs
+++ b/Jint/PreparationOptions.cs
@@ -16,7 +16,7 @@ public sealed record class ScriptPreparationOptions : IPreparationOptions<Script
 {
     private static readonly ParserOptions _defaultParserOptions = ScriptParsingOptions.Default.GetParserOptions() with
     {
-        RegExpParseMode = RegExpParseMode.AdaptToCompiled,
+        OnRegExp = Engine.CompileRegExpHandler,
     };
 
     public static readonly ScriptPreparationOptions Default = new();
@@ -28,14 +28,14 @@ public sealed record class ScriptPreparationOptions : IPreparationOptions<Script
 
     internal ParserOptions GetParserOptions() => ReferenceEquals(this, Default)
         ? _defaultParserOptions
-        : ParsingOptions.ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, _defaultParserOptions.RegexTimeout);
+        : ParsingOptions.ApplyTo(_defaultParserOptions);
 }
 
 public sealed record class ModulePreparationOptions : IPreparationOptions<ModuleParsingOptions>
 {
     private static readonly ParserOptions _defaultParserOptions = ModuleParsingOptions.Default.GetParserOptions() with
     {
-        RegExpParseMode = RegExpParseMode.AdaptToCompiled
+        OnRegExp = Engine.CompileRegExpHandler,
     };
 
     public static readonly ModulePreparationOptions Default = new();
@@ -47,5 +47,5 @@ public sealed record class ModulePreparationOptions : IPreparationOptions<Module
 
     internal ParserOptions GetParserOptions() => ReferenceEquals(this, Default)
         ? _defaultParserOptions
-        : ParsingOptions.ApplyTo(_defaultParserOptions, _defaultParserOptions.RegExpParseMode, _defaultParserOptions.RegexTimeout);
+        : ParsingOptions.ApplyTo(_defaultParserOptions);
 }
diff --git a/Jint/Runtime/Interpreter/Expressions/JintLiteralExpression.cs b/Jint/Runtime/Interpreter/Expressions/JintLiteralExpression.cs
index 148da2cfb2..6ba45a4c29 100644
--- a/Jint/Runtime/Interpreter/Expressions/JintLiteralExpression.cs
+++ b/Jint/Runtime/Interpreter/Expressions/JintLiteralExpression.cs
@@ -1,5 +1,7 @@
 using System.Text.RegularExpressions;
 using Jint.Native;
+using Jint.Native.RegExp;
+using Jint.Runtime.RegExp;
 
 namespace Jint.Runtime.Interpreter.Expressions;
 
@@ -65,14 +67,56 @@ private JsValue ResolveValue(EvaluationContext context)
         var expression = (Literal) _expression;
         if (expression is RegExpLiteral regExpLiteral)
         {
-            var regExpParseResult = regExpLiteral.ParseResult;
-            if (regExpParseResult.Success)
+            var pattern = regExpLiteral.RegExp.Pattern;
+            var flags = regExpLiteral.RegExp.Flags;
+            var regExpConstructor = context.Engine.Realm.Intrinsics.RegExp;
+            var userData = regExpLiteral.UserData;
+
+            // Fast path: reuse cached compiled regex from first evaluation.
+            // Note: UserData assignment below is not synchronized. This is safe because
+            // Engine instances are single-threaded. If a Prepared<Script> is shared across
+            // concurrent Engine instances, the worst case is redundant compilation — both
+            // engines produce equivalent results for the same pattern.
+            if (userData is Regex cachedRegex)
+            {
+                return regExpConstructor.Construct(cachedRegex, pattern, flags);
+            }
+
+            // Fast path: reuse cached custom engine bytecode from first evaluation
+            if (userData is JintRegExpEngine cachedEngine)
+            {
+                return regExpConstructor.Construct(cachedEngine, pattern, flags);
+            }
+
+            // Check for pre-compiled .NET Regex from preparation phase (OnRegExp callback)
+            var parseResult = regExpLiteral.ParseResult;
+            var precompiledRegex = parseResult.Regex;
+            if (precompiledRegex is not null)
+            {
+                regExpLiteral.UserData = precompiledRegex; // cache for next evaluation
+                var r = regExpConstructor.Construct(precompiledRegex, pattern, flags);
+                // Store the group count from preparation
+                if (parseResult.AdditionalData is int groupCount)
+                {
+                    ((JsRegExp) r).ConvertedGroupCount = groupCount;
+                }
+
+                return r;
+            }
+
+            // First evaluation: compile at runtime, then cache the result
+            var jsRegExp = regExpConstructor.RegExpCreate(pattern, flags);
+            var result = (JsRegExp) jsRegExp;
+            if (result.CustomEngine is not null)
+            {
+                regExpLiteral.UserData = result.CustomEngine; // cache bytecode
+            }
+            else if (result.Value is not null)
             {
-                var regex = regExpLiteral.UserData as Regex ?? regExpParseResult.Regex!;
-                return context.Engine.Realm.Intrinsics.RegExp.Construct(regex, regExpLiteral.RegExp.Pattern, regExpLiteral.RegExp.Flags, regExpParseResult);
+                regExpLiteral.UserData = result.Value; // cache .NET Regex
             }
 
-            Throw.SyntaxError(context.Engine.Realm, $"Unsupported regular expression. {regExpParseResult.ConversionError!.Description}");
+            return jsRegExp;
         }
 
         return JsValue.FromObject(context.Engine, expression.Value);
diff --git a/Jint/Runtime/RegExp/JintRegExpEngine.cs b/Jint/Runtime/RegExp/JintRegExpEngine.cs
new file mode 100644
index 0000000000..f8dd104156
--- /dev/null
+++ b/Jint/Runtime/RegExp/JintRegExpEngine.cs
@@ -0,0 +1,121 @@
+using System.Threading;
+
+namespace Jint.Runtime.RegExp;
+
+/// <summary>
+/// Custom JavaScript regex engine based on QuickJS's libregexp.
+/// Used when .NET Regex cannot handle the pattern (v-flag, unicode property escapes,
+/// forward backreferences, semantic differences).
+/// </summary>
+internal sealed class JintRegExpEngine
+{
+    private readonly byte[] _bytecode;
+    private readonly int _captureCount;
+    private readonly string?[] _groupNames = [];
+    private readonly RegExpFlags _flags;
+
+    private JintRegExpEngine(byte[] bytecode)
+    {
+        _bytecode = bytecode;
+        _captureCount = RegExpInterpreter.GetCaptureCount(_bytecode);
+        _flags = RegExpInterpreter.GetFlags(_bytecode);
+        _groupNames = RegExpInterpreter.GetGroupNames(_bytecode) ?? [];
+    }
+
+    /// <summary>Compile a JavaScript regex pattern into bytecode.</summary>
+    public static JintRegExpEngine Compile(string pattern, RegExpFlags flags, CancellationToken cancellationToken = default)
+    {
+        var bytecode = RegExpCompiler.Compile(pattern, flags, cancellationToken);
+        return new JintRegExpEngine(bytecode);
+    }
+
+    /// <summary>Capture group count (including group 0 for full match).</summary>
+    public int CaptureCount => _captureCount;
+
+    /// <summary>Compiled flags.</summary>
+    public RegExpFlags Flags => _flags;
+
+    /// <summary>Get the name of a capture group by its 1-based index.</summary>
+    public string? GetGroupName(int index)
+    {
+        if (index <= 0 || index >= _groupNames.Length)
+        {
+            return null;
+        }
+
+        return _groupNames[index];
+    }
+
+    /// <summary>Execute the regex against the input string starting at the given index.</summary>
+    public RegExpMatchResult Execute(string input, int startIndex, CancellationToken cancellationToken = default)
+    {
+        var captures = RegExpInterpreter.Execute(_bytecode, input, startIndex, cancellationToken);
+        if (captures is null)
+        {
+            return RegExpMatchResult.NoMatch;
+        }
+
+        return BuildResult(input, captures);
+    }
+
+    /// <summary>Test if the regex matches the input string.</summary>
+    public bool IsMatch(string input, int startIndex = 0, CancellationToken cancellationToken = default)
+    {
+        return RegExpInterpreter.Execute(_bytecode, input, startIndex, cancellationToken) is not null;
+    }
+
+    private RegExpMatchResult BuildResult(string input, int[] captures)
+    {
+        // captures[0] = start of full match, captures[1] = end of full match
+        var matchStart = captures[0];
+        var matchEnd = captures[1];
+        var matchValue = input.Substring(matchStart, matchEnd - matchStart);
+
+        RegExpGroupResult[]? groups = null;
+        if (_captureCount > 0)
+        {
+            groups = new RegExpGroupResult[_captureCount];
+
+            // Group 0 = full match
+            groups[0] = new RegExpGroupResult(
+                Success: true,
+                Index: matchStart,
+                Length: matchEnd - matchStart,
+                Value: matchValue,
+                Name: null);
+
+            // Groups 1..N
+            for (var i = 1; i < _captureCount; i++)
+            {
+                var startIdx = captures[i * 2];
+                var endIdx = captures[i * 2 + 1];
+                if (startIdx >= 0 && endIdx >= 0)
+                {
+                    var groupValue = input.Substring(startIdx, endIdx - startIdx);
+                    groups[i] = new RegExpGroupResult(
+                        Success: true,
+                        Index: startIdx,
+                        Length: endIdx - startIdx,
+                        Value: groupValue,
+                        Name: GetGroupName(i));
+                }
+                else
+                {
+                    groups[i] = new RegExpGroupResult(
+                        Success: false,
+                        Index: -1,
+                        Length: 0,
+                        Value: string.Empty,
+                        Name: GetGroupName(i));
+                }
+            }
+        }
+
+        return new RegExpMatchResult(
+            Success: true,
+            Index: matchStart,
+            Length: matchEnd - matchStart,
+            Value: matchValue,
+            Groups: groups);
+    }
+}
diff --git a/Jint/Runtime/RegExp/JsRegExpConverter.cs b/Jint/Runtime/RegExp/JsRegExpConverter.cs
new file mode 100644
index 0000000000..67fa4008f9
--- /dev/null
+++ b/Jint/Runtime/RegExp/JsRegExpConverter.cs
@@ -0,0 +1,472 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace Jint.Runtime.RegExp;
+
+/// <summary>
+/// Lightweight JavaScript regex pattern to .NET Regex converter.
+/// Handles common patterns by rewriting JS-specific escape sequences and anchors
+/// to their .NET standard mode equivalents. Falls back (returns false) for patterns
+/// that require the custom QuickJS engine (Unicode mode, named groups, etc.).
+/// </summary>
+internal static class JsRegExpConverter
+{
+    // JS whitespace characters for \s: TAB, LF, VT, FF, CR, SPACE, NBSP, and Unicode spaces
+    private const string JsWhitespaceChars = "\t\n\v\f\r \u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff";
+
+    // JS word boundary lookaround expansions
+    private const string WordChars = "a-zA-Z0-9_";
+    private const string WordBoundary = "(?:(?<=[" + WordChars + "])(?![" + WordChars + "])|(?<![" + WordChars + "])(?=[" + WordChars + "]))";
+    private const string NonWordBoundary = "(?:(?<=[" + WordChars + "])(?=[" + WordChars + "])|(?<![" + WordChars + "])(?![" + WordChars + "]))";
+
+    // JS line terminators for multiline ^/$
+    private const string LineTerminators = "\n\r\u2028\u2029";
+
+    /// <summary>
+    /// Try to convert a JS regex pattern to a .NET Regex.
+    /// Returns false if the pattern requires the custom engine.
+    /// </summary>
+    public static bool TryConvert(
+        string pattern,
+        string flags,
+        TimeSpan regexTimeout,
+        [NotNullWhen(true)] out Regex? regex,
+        out int groupCount,
+        bool compiled = false)
+    {
+        regex = null;
+        groupCount = 0;
+
+        // Unicode modes require the custom engine
+        if (flags.Contains('u') || flags.Contains('v'))
+        {
+            return false;
+        }
+
+        // Parse flags
+        var ignoreCase = flags.Contains('i');
+        var dotAll = flags.Contains('s');
+        var multiline = flags.Contains('m');
+
+        var options = RegexOptions.CultureInvariant;
+        if (ignoreCase)
+        {
+            options |= RegexOptions.IgnoreCase;
+        }
+
+        if (dotAll)
+        {
+            // Singleline makes . match everything including \n
+            options |= RegexOptions.Singleline;
+        }
+
+        if (compiled)
+        {
+            options |= RegexOptions.Compiled;
+        }
+
+        // Note: do NOT set RegexOptions.Multiline — we rewrite ^/$ ourselves
+
+        var sb = new StringBuilder(pattern.Length + pattern.Length / 2);
+        var groups = 0;
+        var inCharClass = false;
+        var lastCharClassItem = CharClassLastItem.None;
+        var hasBackreference = false;
+        var hasLookaround = false;
+        // Track which groups are still open (not yet closed by ')').
+        // Used to detect self-referencing backreferences like (abc\1).
+        var maxClosedGroup = 0;
+        // Stack to track nesting: true = capturing group, false = non-capturing/assertion
+        var groupStack = new List<bool>(4);
+
+        for (var i = 0; i < pattern.Length; i++)
+        {
+            var ch = pattern[i];
+
+            if (inCharClass)
+            {
+                if (!ConvertInsideCharClass(pattern, ref i, ch, sb, ref lastCharClassItem, ignoreCase))
+                {
+                    return false;
+                }
+
+                if (ch == ']')
+                {
+                    inCharClass = false;
+                }
+
+                continue;
+            }
+
+            switch (ch)
+            {
+                case '.':
+                    if (dotAll)
+                    {
+                        sb.Append('.');
+                    }
+                    else
+                    {
+                        sb.Append("[^\n\r\u2028\u2029]");
+                    }
+
+                    break;
+
+                case '^':
+                    if (multiline)
+                    {
+                        sb.Append("(?:^|(?<=[").Append(LineTerminators).Append("]))");
+                    }
+                    else
+                    {
+                        sb.Append('^');
+                    }
+
+                    break;
+
+                case '$':
+                    if (multiline)
+                    {
+                        sb.Append("(?:\\z|(?=[").Append(LineTerminators).Append("]))");
+                    }
+                    else
+                    {
+                        // Standard .NET $ matches before \n at end; \z matches only at end
+                        sb.Append("\\z");
+                    }
+
+                    break;
+
+                case '[':
+                    inCharClass = true;
+                    lastCharClassItem = CharClassLastItem.None;
+                    sb.Append('[');
+                    // Handle negation
+                    if (i + 1 < pattern.Length && pattern[i + 1] == '^')
+                    {
+                        sb.Append('^');
+                        i++;
+                    }
+                    // Handle ] as first char in class (literal])
+                    if (i + 1 < pattern.Length && pattern[i + 1] == ']')
+                    {
+                        sb.Append(']');
+                        lastCharClassItem = CharClassLastItem.SingleChar;
+                        i++;
+                    }
+
+                    break;
+
+                case '\\':
+                    if (!ConvertEscapeSequence(pattern, ref i, sb, ignoreCase, ref groups, ref hasBackreference, maxClosedGroup))
+                    {
+                        return false;
+                    }
+
+                    break;
+
+                case '(':
+                    if (i + 1 < pattern.Length && pattern[i + 1] == '?')
+                    {
+                        if (i + 2 >= pattern.Length)
+                        {
+                            return false;
+                        }
+
+                        var ch2 = pattern[i + 2];
+
+                        switch (ch2)
+                        {
+                            // Non-capturing group (?:...) — pass through
+                            case ':':
+                                groupStack.Add(false);
+                                sb.Append("(?");
+                                i++;
+                                break;
+
+                            // Lookahead (?=...) and (?!...) — pass through but track
+                            case '=' or '!':
+                                hasLookaround = true;
+                                groupStack.Add(false);
+                                sb.Append("(?");
+                                i++;
+                                break;
+
+                            // Lookbehind (?<=...) and (?<!...)
+                            case '<' when i + 3 < pattern.Length && pattern[i + 3] is '=' or '!':
+                                hasLookaround = true;
+                                groupStack.Add(false);
+                                sb.Append("(?");
+                                i++;
+                                break;
+
+                            // Named groups (?<name>...) — bail (group numbering complexity)
+                            case '<':
+                                return false;
+
+                            default:
+                                // Scoped modifiers (?i:...), (?-m:...), or any other (?X — bail
+                                return false;
+                        }
+                    }
+                    else
+                    {
+                        // Capturing group
+                        groups++;
+                        groupStack.Add(true);
+                        sb.Append('(');
+                    }
+
+                    break;
+
+                case ')':
+                    sb.Append(')');
+                    if (groupStack.Count > 0)
+                    {
+                        var wasCapturing = groupStack[groupStack.Count - 1];
+                        groupStack.RemoveAt(groupStack.Count - 1);
+                        if (wasCapturing)
+                        {
+                            maxClosedGroup++;
+                        }
+                    }
+
+                    break;
+
+                default:
+                    sb.Append(ch);
+                    break;
+            }
+        }
+
+        // .NET standard mode treats backreferences to uncaptured groups as failure.
+        // JS treats them as matching empty. This matters when groups are defined inside
+        // lookahead/lookbehind — after the assertion, those groups may be uncaptured.
+        if (hasBackreference && hasLookaround)
+        {
+            return false;
+        }
+
+        groupCount = groups + 1; // +1 for group 0 (full match)
+
+        try
+        {
+            regex = new Regex(sb.ToString(), options, regexTimeout);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Convert an escape sequence outside a character class.
+    /// </summary>
+    private static bool ConvertEscapeSequence(string pattern, ref int i, StringBuilder sb, bool ignoreCase, ref int groups, ref bool hasBackreference, int maxClosedGroup)
+    {
+        i++; // skip the backslash
+        if (i >= pattern.Length)
+        {
+            sb.Append('\\');
+            i--;
+            return true;
+        }
+
+        var next = pattern[i];
+        switch (next)
+        {
+            case 'd':
+                sb.Append("[0-9]");
+                break;
+            case 'D':
+                sb.Append("[^0-9]");
+                break;
+            case 'w':
+                if (ignoreCase)
+                {
+                    return false; // case folding edge cases (U+017F, U+212A)
+                }
+
+                sb.Append("[" + WordChars + "]");
+                break;
+            case 'W':
+                if (ignoreCase)
+                {
+                    return false;
+                }
+
+                sb.Append("[^" + WordChars + "]");
+                break;
+            case 's':
+                sb.Append('[').Append(JsWhitespaceChars).Append(']');
+                break;
+            case 'S':
+                sb.Append("[^").Append(JsWhitespaceChars).Append(']');
+                break;
+            case 'b':
+                sb.Append(WordBoundary);
+                break;
+            case 'B':
+                sb.Append(NonWordBoundary);
+                break;
+            case 'c':
+                return false; // \c control escapes — Annex B divergence
+            case 'k':
+                // Named backreference \k<name>
+                if (i + 1 < pattern.Length && pattern[i + 1] == '<')
+                {
+                    return false;
+                }
+
+                sb.Append("\\k");
+                break;
+            case 'p' or 'P':
+                // Unicode property escape \p{...} / \P{...}
+                if (i + 1 < pattern.Length && pattern[i + 1] == '{')
+                {
+                    return false;
+                }
+
+                sb.Append('\\').Append(next);
+                break;
+            case >= '1' and <= '9':
+                // Parse the full backreference number
+                var refStart = i;
+                while (i + 1 < pattern.Length && pattern[i + 1] is >= '0' and <= '9')
+                {
+                    i++;
+                }
+
+                var refNumStr = pattern.AsSpan(refStart, i - refStart + 1);
+                if (int.TryParse(refNumStr, System.Globalization.NumberStyles.None, System.Globalization.CultureInfo.InvariantCulture, out var refNum) && refNum > maxClosedGroup)
+                {
+                    // Backreference to a group that hasn't been fully closed yet
+                    // (self-referencing like (abc\1)). In .NET standard mode,
+                    // uncaptured backreferences fail instead of matching empty.
+                    return false;
+                }
+
+                hasBackreference = true;
+                sb.Append('\\');
+                sb.Append(pattern, refStart, i - refStart + 1);
+                break;
+            default:
+                // Pass through: \t, \n, \r, \f, \v, \0, \uXXXX, \xHH, \\, etc.
+                sb.Append('\\').Append(next);
+                break;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Convert a character inside a character class [...].
+    /// </summary>
+    private static bool ConvertInsideCharClass(string pattern, ref int i, char ch, StringBuilder sb, ref CharClassLastItem lastItem, bool ignoreCase)
+    {
+        switch (ch)
+        {
+            case ']':
+                sb.Append(']');
+                return true;
+
+            case '\\':
+                i++;
+                if (i >= pattern.Length)
+                {
+                    return false; // unterminated escape
+                }
+
+                var next = pattern[i];
+                switch (next)
+                {
+                    case 'd':
+                        EmitCharClassShorthand(sb, "0-9", ref lastItem);
+                        break;
+                    case 'D' or 'W' or 'S':
+                        return false; // Negated shorthand inside char class — bail
+                    case 'w':
+                        if (ignoreCase)
+                        {
+                            return false;
+                        }
+
+                        EmitCharClassShorthand(sb, WordChars, ref lastItem);
+                        break;
+                    case 's':
+                        EmitCharClassShorthand(sb, JsWhitespaceChars, ref lastItem);
+                        break;
+                    case 'b':
+                        // \b inside char class is backspace (\x08) in JS
+                        sb.Append("\\x08");
+                        lastItem = CharClassLastItem.SingleChar;
+                        break;
+                    case 'c':
+                        return false; // \c control escape — bail
+                    case 'p' or 'P':
+                        if (i + 1 < pattern.Length && pattern[i + 1] == '{')
+                        {
+                            return false; // Unicode property escape
+                        }
+
+                        sb.Append('\\').Append(next);
+                        lastItem = CharClassLastItem.SingleChar;
+                        break;
+                    default:
+                        sb.Append('\\').Append(next);
+                        lastItem = CharClassLastItem.SingleChar;
+                        break;
+                }
+
+                break;
+
+            case '-':
+                if (lastItem == CharClassLastItem.ShorthandExpansion)
+                {
+                    // Dash after shorthand expansion (e.g., [\d-a]) — escape dash to avoid range
+                    sb.Append("\\x2D");
+                    lastItem = CharClassLastItem.SingleChar;
+                }
+                else
+                {
+                    sb.Append('-');
+                    lastItem = CharClassLastItem.Dash;
+                }
+
+                break;
+
+            default:
+                sb.Append(ch);
+                lastItem = CharClassLastItem.SingleChar;
+                break;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Emit a shorthand expansion inside a character class, handling dash-before-shorthand edge case.
+    /// </summary>
+    private static void EmitCharClassShorthand(StringBuilder sb, string expansion, ref CharClassLastItem lastItem)
+    {
+        if (lastItem == CharClassLastItem.Dash)
+        {
+            // Previous was a dash, like [a-\d] — escape the dash we already emitted
+            sb.Remove(sb.Length - 1, 1);
+            sb.Append("\\x2D");
+        }
+
+        sb.Append(expansion);
+        lastItem = CharClassLastItem.ShorthandExpansion;
+    }
+
+    private enum CharClassLastItem : byte
+    {
+        None,
+        SingleChar,
+        ShorthandExpansion,
+        Dash,
+    }
+}
diff --git a/Jint/Runtime/RegExp/RegExpCompiler.cs b/Jint/Runtime/RegExp/RegExpCompiler.cs
new file mode 100644
index 0000000000..c8507b163e
--- /dev/null
+++ b/Jint/Runtime/RegExp/RegExpCompiler.cs
@@ -0,0 +1,2832 @@
+// Ported from QuickJS libregexp.c
+//
+// Copyright (c) 2017-2018 Fabrice Bellard
+//
+// 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.
+
+using System.Buffers.Binary;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Threading;
+using Jint.Runtime.RegExp.Unicode;
+
+namespace Jint.Runtime.RegExp;
+
+// Section: CharRange helper
+
+/// <summary>
+/// Manages a sorted list of [start, end) code point intervals stored as flat uint values.
+/// Port of the C CharRange struct and cr_* functions from libunicode.
+/// </summary>
+internal sealed class CharRange
+{
+    /// <summary>Points sorted by increasing value. Length is always even (start/end pairs).</summary>
+    public readonly List<uint> Points = new();
+
+    public int Length => Points.Count;
+
+    public void Clear()
+    {
+        Points.Clear();
+    }
+
+    public void AddPoint(uint v)
+    {
+        Points.Add(v);
+    }
+
+    public void AddInterval(uint c1, uint c2)
+    {
+        Points.Add(c1);
+        Points.Add(c2);
+    }
+
+    public void CopyFrom(CharRange other)
+    {
+        Points.Clear();
+        Points.AddRange(other.Points);
+    }
+
+    /// <summary>
+    /// Union a single character interval [c1, c2+1). Port of cr_union_interval.
+    /// </summary>
+    public void UnionInterval(uint c1, uint c2)
+    {
+        uint[] bPt = [c1, c2 + 1];
+        Op1(bPt, CharRangeOp.Union);
+    }
+
+    /// <summary>
+    /// Invert the character range (complement). Port of cr_invert.
+    /// </summary>
+    public void Invert()
+    {
+        var pts = Points;
+        int len = pts.Count;
+
+        if (len == 0)
+        {
+            pts.Add(0);
+            pts.Add(CharRangeHelpers.CharRangeMax);
+            return;
+        }
+
+        if (pts[0] == 0)
+        {
+            pts.RemoveAt(0);
+        }
+        else
+        {
+            pts.Insert(0, 0);
+        }
+
+        if (pts.Count > 0 && pts[^1] == CharRangeHelpers.CharRangeMax)
+        {
+            pts.RemoveAt(pts.Count - 1);
+        }
+        else
+        {
+            pts.Add(CharRangeHelpers.CharRangeMax);
+        }
+    }
+
+    /// <summary>
+    /// Apply set operation: a = a op b. Port of cr_op1.
+    /// </summary>
+    public void Op1(ReadOnlySpan<uint> bPt, CharRangeOp op)
+    {
+        var aPt = Points.ToArray();
+        var result = new List<uint>();
+        CharRangeHelpers.Op(result, aPt, bPt, op);
+        Points.Clear();
+        Points.AddRange(result);
+    }
+
+    /// <summary>
+    /// Apply set operation: a = a op b (where b is another CharRange).
+    /// </summary>
+    public void Op1(CharRange b, CharRangeOp op)
+    {
+        Op1(b.Points.ToArray().AsSpan(), op);
+    }
+
+    /// <summary>
+    /// Canonicalize the range for case-insensitive matching.
+    /// Port of cr_regexp_canonicalize.
+    /// </summary>
+    public void RegexpCanonicalize(bool isUnicode)
+    {
+        UnicodeProperties.CrCanonicalize(Points, isUnicode);
+    }
+}
+
+// Section: CharRange set operations
+
+internal static class CharRangeHelpers
+{
+    /// <summary>
+    /// Range extends beyond the maximum Unicode code point.
+    /// In the C code this corresponds to ranges up to UINT32_MAX.
+    /// </summary>
+    public const uint CharRangeMax = 0x110000;
+
+    /// <summary>
+    /// Port of cr_op: compute result = a op b (union, inter, xor, sub).
+    /// Both a and b must be sorted non-overlapping interval arrays with [start, end) pairs.
+    /// </summary>
+    public static void Op(List<uint> result, ReadOnlySpan<uint> a, ReadOnlySpan<uint> b, CharRangeOp op)
+    {
+        int ai = 0, bi = 0;
+        int aLen = a.Length, bLen = b.Length;
+        bool inA = false, inB = false;
+        bool prevInResult = false;
+
+        // Merge all boundary points from both ranges
+        while (ai < aLen || bi < bLen)
+        {
+            uint va = ai < aLen ? a[ai] : uint.MaxValue;
+            uint vb = bi < bLen ? b[bi] : uint.MaxValue;
+            uint v;
+
+            if (va <= vb)
+            {
+                v = va;
+                ai++;
+                inA = !inA;
+            }
+            else
+            {
+                v = vb;
+                bi++;
+                inB = !inB;
+            }
+
+            // Handle ties
+            if (va == vb && bi <= bLen && ai <= aLen && va != uint.MaxValue)
+            {
+                if (bi < bLen || (bi == bLen && vb == va))
+                {
+                    // If both had the same value, we already consumed 'a',
+                    // now consume 'b' too
+                    if (va == vb && bi > 0 && b[bi - 1] == va)
+                    {
+                        // Already handled
+                    }
+                    else if (va == vb)
+                    {
+                        bi++;
+                        inB = !inB;
+                    }
+                }
+            }
+
+            bool inResult = op switch
+            {
+                CharRangeOp.Union => inA || inB,
+                CharRangeOp.Inter => inA && inB,
+                CharRangeOp.Xor => inA ^ inB,
+                CharRangeOp.Sub => inA && !inB,
+                _ => false,
+            };
+
+            if (inResult != prevInResult)
+            {
+                result.Add(v);
+                prevInResult = inResult;
+            }
+        }
+    }
+}
+
+// Section: REStringList
+
+/// <summary>
+/// Represents a set of characters (via CharRange) plus multi-codepoint strings
+/// (via a HashSet). Used for unicode-sets (v-flag) character class operations.
+/// Port of the C REStringList struct.
+/// </summary>
+internal sealed class REStringList
+{
+    public readonly CharRange Cr = new();
+    private readonly HashSet<string> _strings = new(StringComparer.Ordinal);
+
+    public int StringCount => _strings.Count;
+
+    public void Clear()
+    {
+        Cr.Clear();
+        _strings.Clear();
+    }
+
+    /// <summary>
+    /// Add a code point sequence. Single code points go into the char range;
+    /// multi-codepoint sequences go into the string hash set.
+    /// Port of re_string_add.
+    /// </summary>
+    public void Add(ReadOnlySpan<uint> buf)
+    {
+        if (buf.Length == 1)
+        {
+            Cr.UnionInterval(buf[0], buf[0]);
+        }
+        else
+        {
+            _strings.Add(CodePointsToString(buf));
+        }
+    }
+
+    /// <summary>a = a op b. Port of re_string_list_op.</summary>
+    public void Op(REStringList b, CharRangeOp op)
+    {
+        Cr.Op1(b.Cr, op);
+
+        switch (op)
+        {
+            case CharRangeOp.Union:
+                foreach (var s in b._strings)
+                    _strings.Add(s);
+                break;
+
+            case CharRangeOp.Inter:
+                _strings.IntersectWith(b._strings);
+                break;
+
+            case CharRangeOp.Sub:
+                _strings.ExceptWith(b._strings);
+                break;
+
+            default:
+                throw new InvalidOperationException("Unsupported string list operation");
+        }
+    }
+
+    /// <summary>
+    /// Canonicalize all strings and char ranges for case-insensitive matching.
+    /// Port of re_string_list_canonicalize.
+    /// </summary>
+    public void Canonicalize(bool isUnicode)
+    {
+        Cr.RegexpCanonicalize(isUnicode);
+
+        if (_strings.Count != 0)
+        {
+            var original = new string[_strings.Count];
+            _strings.CopyTo(original);
+            _strings.Clear();
+
+            foreach (var s in original)
+            {
+                var cps = StringToCodePoints(s);
+                for (int j = 0; j < cps.Length; j++)
+                {
+                    cps[j] = UnicodeProperties.Canonicalize(cps[j], isUnicode);
+                }
+                Add(cps);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Get all multi-char strings sorted by descending length (longest first).
+    /// Used for emitting match alternatives.
+    /// </summary>
+    public List<uint[]> GetStringsSortedByLengthDesc()
+    {
+        var list = new List<uint[]>();
+        foreach (var s in _strings)
+        {
+            var cps = StringToCodePoints(s);
+            if (cps.Length > 0)
+                list.Add(cps);
+        }
+        // Sort by length descending (longest first for greedy matching)
+        list.Sort((a, b) => b.Length.CompareTo(a.Length));
+        return list;
+    }
+
+    public bool HasEmptyString()
+    {
+        return _strings.Contains("");
+    }
+
+    private static string CodePointsToString(ReadOnlySpan<uint> buf)
+    {
+        var sb = new System.Text.StringBuilder(buf.Length);
+        foreach (uint cp in buf)
+        {
+            if (cp <= 0xFFFF)
+                sb.Append((char) cp);
+            else
+                sb.Append(char.ConvertFromUtf32((int) cp));
+        }
+        return sb.ToString();
+    }
+
+    private static uint[] StringToCodePoints(string s)
+    {
+        var list = new List<uint>();
+        for (int i = 0; i < s.Length; i++)
+        {
+            uint cp;
+            if (char.IsHighSurrogate(s[i]) && i + 1 < s.Length && char.IsLowSurrogate(s[i + 1]))
+            {
+                cp = (uint) char.ConvertToUtf32(s[i], s[i + 1]);
+                i++;
+            }
+            else
+            {
+                cp = s[i];
+            }
+            list.Add(cp);
+        }
+        return list.ToArray();
+    }
+}
+
+// Section: Character range enum for built-in classes
+
+internal enum CharRangeEnum : uint
+{
+    Digit = 0,      // \d
+    NotDigit = 1,    // \D
+    Space = 2,       // \s
+    NotSpace = 3,    // \S
+    Word = 4,        // \w
+    NotWord = 5,     // \W
+}
+
+// Section: Group name entry
+
+[StructLayout(LayoutKind.Auto)]
+internal readonly record struct GroupNameEntry(string? Name, byte Scope);
+
+// Section: Compiler entry point
+
+/// <summary>
+/// Compiles JavaScript regex patterns to bytecode.
+/// Faithfully ported from QuickJS libregexp.c (lre_compile and supporting functions).
+/// </summary>
+internal static class RegExpCompiler
+{
+    private const int CaptureCountMax = 255;
+    private const int RegisterCountMax = 255;
+    private const uint ClassRangeBase = 0x40000000;
+
+    /// <summary>
+    /// Trailer length after the group name including the trailing '\0'.
+    /// Matches LRE_GROUP_NAME_TRAILER_LEN in the C code.
+    /// </summary>
+    private const int GroupNameTrailerLen = 2;
+
+    // Section: Built-in character class ranges (same data as C code)
+
+    private static ReadOnlySpan<ushort> CharRangeD =>
+    [
+        1,
+        0x0030, 0x0039 + 1,
+    ];
+
+    private static ReadOnlySpan<ushort> CharRangeS =>
+    [
+        10,
+        0x0009, 0x000D + 1,
+        0x0020, 0x0020 + 1,
+        0x00A0, 0x00A0 + 1,
+        0x1680, 0x1680 + 1,
+        0x2000, 0x200A + 1,
+        0x2028, 0x2029 + 1,
+        0x202F, 0x202F + 1,
+        0x205F, 0x205F + 1,
+        0x3000, 0x3000 + 1,
+        0xFEFF, 0xFEFF + 1,
+    ];
+
+    private static ReadOnlySpan<ushort> CharRangeW =>
+    [
+        4,
+        0x0030, 0x0039 + 1,
+        0x0041, 0x005A + 1,
+        0x005F, 0x005F + 1,
+        0x0061, 0x007A + 1,
+    ];
+
+    // Section: Public API
+
+    private static bool IsAsciiDigit(char c) => c is >= '0' and <= '9';
+
+    /// <summary>
+    /// Compile a JavaScript regular expression pattern into bytecode.
+    /// </summary>
+    /// <param name="pattern">The regex pattern string (without delimiters).</param>
+    /// <param name="flags">The regex flags.</param>
+    /// <param name="cancellationToken">Optional cancellation token for timeout/abort.</param>
+    /// <returns>The compiled bytecode including the 8-byte header.</returns>
+    /// <exception cref="RegExpSyntaxException">Thrown on syntax errors in the pattern.</exception>
+    public static byte[] Compile(string pattern, RegExpFlags flags, CancellationToken cancellationToken = default)
+    {
+        var s = new REParseState(pattern, flags, cancellationToken);
+        return s.Compile();
+    }
+
+    // Section: Parse state
+
+    /// <summary>
+    /// Internal parse state for the regex compiler. Corresponds to REParseState in the C code.
+    /// </summary>
+    private sealed class REParseState
+    {
+        // Bytecode buffer (replaces DynBuf)
+        private readonly List<byte> _byteCode = new();
+
+        // Pattern input
+        private readonly string _pattern;
+        private int _pos;
+        private readonly int _patternEnd;
+
+        // Flags
+        private readonly RegExpFlags _reFlags;
+        internal readonly bool IsUnicode;
+        internal readonly bool UnicodeSets;
+        internal bool IgnoreCase;
+        internal bool MultiLine;
+        internal bool DotAll;
+
+        // Capture and group tracking
+        internal byte GroupNameScope;
+        internal int CaptureCount;
+        internal int TotalCaptureCount;
+        internal int HasNamedCaptures; // -1 = don't know, 0 = no, 1 = yes
+        internal readonly List<GroupNameEntry> GroupNames = new();
+
+        // Cancellation and stack overflow protection
+        private readonly CancellationToken _cancellationToken;
+        private int _recursionDepth;
+        private const int MaxRecursionDepth = 256;
+
+        internal REParseState(string pattern, RegExpFlags flags, CancellationToken cancellationToken)
+        {
+            _pattern = pattern;
+            _pos = 0;
+            _patternEnd = pattern.Length;
+            _reFlags = flags;
+            IsUnicode = (flags & (RegExpFlags.Unicode | RegExpFlags.UnicodeSets)) != RegExpFlags.None;
+            UnicodeSets = (flags & RegExpFlags.UnicodeSets) != RegExpFlags.None;
+            IgnoreCase = (flags & RegExpFlags.IgnoreCase) != RegExpFlags.None;
+            MultiLine = (flags & RegExpFlags.Multiline) != RegExpFlags.None;
+            DotAll = (flags & RegExpFlags.DotAll) != RegExpFlags.None;
+            CaptureCount = 1;
+            TotalCaptureCount = -1;
+            HasNamedCaptures = -1;
+            _cancellationToken = cancellationToken;
+        }
+
+        // Section: Compile entry point (port of lre_compile)
+
+        internal byte[] Compile()
+        {
+            bool isSticky = (_reFlags & RegExpFlags.Sticky) != RegExpFlags.None;
+
+            // Write 8-byte header placeholder
+            EmitU16((ushort) _reFlags);   // offset 0: flags
+            EmitByte(0);                  // offset 2: capture count (filled later)
+            EmitByte(0);                  // offset 3: register count (filled later)
+            EmitU32(0);                   // offset 4: bytecode length (filled later)
+
+            if (!isSticky)
+            {
+                // Iterate through all positions (equivalent to .*?(...))
+                // We do it without an explicit loop so that lock-step thread
+                // execution will be possible in an optimized implementation.
+                EmitOpU32(RegExpOpcode.SplitGotoFirst, 1 + 5);
+                EmitOp(RegExpOpcode.Any);
+                EmitOpU32(RegExpOpcode.Goto, unchecked((uint) (-(5 + 1 + 5))));
+            }
+            EmitOpU8(RegExpOpcode.SaveStart, 0);
+
+            ParseDisjunction(false);
+
+            EmitOpU8(RegExpOpcode.SaveEnd, 0);
+            EmitOp(RegExpOpcode.Match);
+
+            if (_pos != _patternEnd)
+            {
+                throw new RegExpSyntaxException("extraneous characters at the end");
+            }
+
+            int registerCount = ComputeRegisterCount();
+            if (registerCount < 0)
+            {
+                throw new RegExpSyntaxException("too many imbricated quantifiers");
+            }
+
+            _byteCode[RegExpHeader.OffsetCaptureCount] = (byte) CaptureCount;
+            _byteCode[RegExpHeader.OffsetRegisterCount] = (byte) registerCount;
+            PutU32(RegExpHeader.OffsetBytecodeLen, (uint) (_byteCode.Count - RegExpHeader.Length));
+
+            // Add the named groups if needed
+            bool hasRealNames = false;
+            foreach (var gn in GroupNames)
+            {
+                if (gn.Name is { Length: > 0 })
+                {
+                    hasRealNames = true;
+                    break;
+                }
+            }
+
+            if (hasRealNames)
+            {
+                SerializeGroupNames();
+                ushort currentFlags = ReadU16(RegExpHeader.OffsetFlags);
+                PutU16(RegExpHeader.OffsetFlags, (ushort) (currentFlags | (ushort) RegExpFlags.NamedGroups));
+            }
+            else
+            {
+                SerializeGroupNames();
+            }
+
+            return _byteCode.ToArray();
+        }
+
+        // Section: Bytecode emission helpers
+
+        private void EmitByte(byte b)
+        {
+            _byteCode.Add(b);
+        }
+
+        private void EmitOp(RegExpOpcode op)
+        {
+            _byteCode.Add((byte) op);
+        }
+
+        /// <summary>Emit opcode + u32 value. Returns the offset of the u32.</summary>
+        private int EmitOpU32(RegExpOpcode op, uint val)
+        {
+            _byteCode.Add((byte) op);
+            int pos = _byteCode.Count;
+            EmitU32(val);
+            return pos;
+        }
+
+        /// <summary>Emit goto-style opcode with relative offset. Returns offset of the u32.</summary>
+        private int EmitGoto(RegExpOpcode op, int target)
+        {
+            _byteCode.Add((byte) op);
+            int pos = _byteCode.Count;
+            int rel = target - (pos + 4);
+            EmitU32((uint) rel);
+            return pos;
+        }
+
+        /// <summary>Emit goto with a u8 arg then relative offset. Returns offset of the u32.</summary>
+        private int EmitGotoU8(RegExpOpcode op, byte arg, int target)
+        {
+            _byteCode.Add((byte) op);
+            _byteCode.Add(arg);
+            int pos = _byteCode.Count;
+            int rel = target - (pos + 4);
+            EmitU32((uint) rel);
+            return pos;
+        }
+
+        /// <summary>
+        /// Emit goto with u8 arg, u32 arg, then relative offset.
+        /// Returns offset of the u32 goto.
+        /// </summary>
+        private int EmitGotoU8U32(RegExpOpcode op, byte arg0, uint arg1, int target)
+        {
+            _byteCode.Add((byte) op);
+            _byteCode.Add(arg0);
+            EmitU32(arg1);
+            int pos = _byteCode.Count;
+            int rel = target - (pos + 4);
+            EmitU32((uint) rel);
+            return pos;
+        }
+
+        private void EmitOpU8(RegExpOpcode op, byte val)
+        {
+            _byteCode.Add((byte) op);
+            _byteCode.Add(val);
+        }
+
+        private void EmitOpU16(RegExpOpcode op, ushort val)
+        {
+            _byteCode.Add((byte) op);
+            EmitU16(val);
+        }
+
+        /// <summary>
+        /// Emit a character match opcode (Char/Char32, with or without case-insensitive variant).
+        /// Port of re_emit_char.
+        /// </summary>
+        private void EmitChar(uint c)
+        {
+            if (c <= 0xFFFF)
+                EmitOpU16(IgnoreCase ? RegExpOpcode.CharI : RegExpOpcode.Char, (ushort) c);
+            else
+                EmitOpU32(IgnoreCase ? RegExpOpcode.Char32I : RegExpOpcode.Char32, c);
+        }
+
+        private void EmitU16(ushort val)
+        {
+            Span<byte> buf = stackalloc byte[2];
+            BinaryPrimitives.WriteUInt16LittleEndian(buf, val);
+            _byteCode.Add(buf[0]);
+            _byteCode.Add(buf[1]);
+        }
+
+        private void EmitU32(uint val)
+        {
+            Span<byte> buf = stackalloc byte[4];
+            BinaryPrimitives.WriteUInt32LittleEndian(buf, val);
+            _byteCode.Add(buf[0]);
+            _byteCode.Add(buf[1]);
+            _byteCode.Add(buf[2]);
+            _byteCode.Add(buf[3]);
+        }
+
+        private void PutU32(int offset, uint val)
+        {
+            Span<byte> buf = stackalloc byte[4];
+            BinaryPrimitives.WriteUInt32LittleEndian(buf, val);
+            _byteCode[offset] = buf[0];
+            _byteCode[offset + 1] = buf[1];
+            _byteCode[offset + 2] = buf[2];
+            _byteCode[offset + 3] = buf[3];
+        }
+
+        private uint ReadU32(int offset)
+        {
+            Span<byte> buf =
+            [
+                _byteCode[offset], _byteCode[offset + 1],
+                _byteCode[offset + 2], _byteCode[offset + 3]
+            ];
+            return BinaryPrimitives.ReadUInt32LittleEndian(buf);
+        }
+
+        private void PutU16(int offset, ushort val)
+        {
+            Span<byte> buf = stackalloc byte[2];
+            BinaryPrimitives.WriteUInt16LittleEndian(buf, val);
+            _byteCode[offset] = buf[0];
+            _byteCode[offset + 1] = buf[1];
+        }
+
+        private ushort ReadU16(int offset)
+        {
+            Span<byte> buf = [_byteCode[offset], _byteCode[offset + 1]];
+            return BinaryPrimitives.ReadUInt16LittleEndian(buf);
+        }
+
+        /// <summary>Insert 'len' zero bytes at 'pos'. Port of dbuf_insert.</summary>
+        private void ByteCodeInsert(int pos, int len)
+        {
+            if (len <= 0) return;
+            _byteCode.InsertRange(pos, new byte[len]);
+        }
+
+        // Section: Pattern input helpers
+
+        /// <summary>Read one code point, handling surrogates in unicode mode.</summary>
+        private int ReadChar()
+        {
+            if (_pos >= _patternEnd) return -1;
+            char c = _pattern[_pos++];
+            if (IsUnicode && char.IsHighSurrogate(c) &&
+                _pos < _patternEnd && char.IsLowSurrogate(_pattern[_pos]))
+            {
+                return char.ConvertToUtf32(c, _pattern[_pos++]);
+            }
+            return c;
+        }
+
+        private void CheckStackOverflow()
+        {
+            _cancellationToken.ThrowIfCancellationRequested();
+            if (++_recursionDepth > MaxRecursionDepth)
+            {
+                throw new RegExpSyntaxException("stack overflow");
+            }
+        }
+
+        private void DecrementRecursionDepth()
+        {
+            _recursionDepth--;
+        }
+
+        // Section: Digit parsing (port of parse_digits)
+
+        /// <summary>
+        /// Parse decimal digits starting at current position.
+        /// If allowOverflow, clamps to int.MaxValue; otherwise returns -1 on overflow.
+        /// </summary>
+        private int ParseDigits(bool allowOverflow)
+        {
+            long v = 0;
+            while (_pos < _patternEnd)
+            {
+                int c = _pattern[_pos];
+                if (c < '0' || c > '9') break;
+                v = v * 10 + (c - '0');
+                if (v >= int.MaxValue)
+                {
+                    if (allowOverflow)
+                        v = int.MaxValue;
+                    else
+                        return -1;
+                }
+                _pos++;
+            }
+            return (int) v;
+        }
+
+        /// <summary>
+        /// Parse decimal digits at a given position (does not modify _pos).
+        /// </summary>
+        private static int ParseDigitsAt(string pattern, ref int pos, int end, bool allowOverflow)
+        {
+            long v = 0;
+            while (pos < end)
+            {
+                int c = pattern[pos];
+                if (c < '0' || c > '9') break;
+                v = v * 10 + (c - '0');
+                if (v >= int.MaxValue)
+                {
+                    if (allowOverflow)
+                        v = int.MaxValue;
+                    else
+                        return -1;
+                }
+                pos++;
+            }
+            return (int) v;
+        }
+
+        // Section: Expect character (port of re_parse_expect)
+
+        private void ParseExpect(char expected)
+        {
+            if (_pos >= _patternEnd || _pattern[_pos] != expected)
+            {
+                throw new RegExpSyntaxException($"expecting '{expected}'");
+            }
+            _pos++;
+        }
+
+        // Section: Hex parsing (port of from_hex)
+
+        private static int FromHex(int c)
+        {
+            if (c >= '0' && c <= '9') return c - '0';
+            if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+            if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+            return -1;
+        }
+
+        // Section: Surrogate helpers
+
+        private static bool IsHighSurrogate(uint c) => (c >> 10) == (0xD800 >> 10);
+        private static bool IsLowSurrogate(uint c) => (c >> 10) == (0xDC00 >> 10);
+        private static uint FromSurrogatePair(uint hi, uint lo) => 0x10000 + 0x400 * (hi - 0xD800) + (lo - 0xDC00);
+
+        // Section: Escape sequence parsing (port of lre_parse_escape)
+
+        /// <summary>
+        /// Parse an escape sequence. _pos points after the '\'.
+        /// allowUtf16: 0=no UTF-16, 1=UTF-16 allowed, 2=UTF-16 + surrogate pair conversion.
+        /// Returns the character, -1 (malformed), or -2 (unrecognized).
+        /// </summary>
+        private int ParseEscape(int allowUtf16)
+        {
+            if (_pos >= _patternEnd) return -1;
+            int c = _pattern[_pos++];
+
+            switch (c)
+            {
+                case 'b': return '\b';
+                case 'f': return '\f';
+                case 'n': return '\n';
+                case 'r': return '\r';
+                case 't': return '\t';
+                case 'v': return 0x0B;
+
+                case 'x':
+                    {
+                        if (_pos >= _patternEnd) return -1;
+                        int h0 = FromHex(_pattern[_pos++]);
+                        if (h0 < 0) return -1;
+                        if (_pos >= _patternEnd) return -1;
+                        int h1 = FromHex(_pattern[_pos++]);
+                        if (h1 < 0) return -1;
+                        return (h0 << 4) | h1;
+                    }
+
+                case 'u':
+                    {
+                        if (_pos < _patternEnd && _pattern[_pos] == '{' && allowUtf16 != 0)
+                        {
+                            _pos++; // skip '{'
+                            uint cv = 0;
+                            bool hasDigit = false;
+                            for (; ; )
+                            {
+                                if (_pos >= _patternEnd) return -1;
+                                int h = FromHex(_pattern[_pos]);
+                                if (h < 0)
+                                {
+                                    if (_pattern[_pos] == '}' && hasDigit) break;
+                                    return -1;
+                                }
+                                _pos++;
+                                hasDigit = true;
+                                cv = (cv << 4) | (uint) h;
+                                if (cv > 0x10FFFF) return -1;
+                            }
+                            if (_pos >= _patternEnd || _pattern[_pos] != '}') return -1;
+                            _pos++; // skip '}'
+                            return (int) cv;
+                        }
+                        else
+                        {
+                            uint cv = 0;
+                            for (int i = 0; i < 4; i++)
+                            {
+                                if (_pos >= _patternEnd) return -1;
+                                int h = FromHex(_pattern[_pos++]);
+                                if (h < 0) return -1;
+                                cv = (cv << 4) | (uint) h;
+                            }
+
+                            // Check for surrogate pair in unicode mode
+                            if (IsHighSurrogate(cv) && allowUtf16 == 2 &&
+                                _pos + 1 < _patternEnd &&
+                                _pattern[_pos] == '\\' && _pattern[_pos + 1] == 'u')
+                            {
+                                int savedPos = _pos;
+                                _pos += 2; // skip \u
+                                uint c1 = 0;
+                                bool ok = true;
+                                for (int i = 0; i < 4; i++)
+                                {
+                                    if (_pos >= _patternEnd) { ok = false; break; }
+                                    int h = FromHex(_pattern[_pos++]);
+                                    if (h < 0) { ok = false; break; }
+                                    c1 = (c1 << 4) | (uint) h;
+                                }
+                                if (ok && IsLowSurrogate(c1))
+                                {
+                                    return (int) FromSurrogatePair(cv, c1);
+                                }
+                                _pos = savedPos;
+                            }
+                            return (int) cv;
+                        }
+                    }
+
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                    {
+                        uint cv = (uint) (c - '0');
+                        if (allowUtf16 == 2)
+                        {
+                            // Only accept \0 not followed by a digit
+                            if (cv != 0 || (_pos < _patternEnd && IsAsciiDigit(_pattern[_pos])))
+                                return -1;
+                        }
+                        else
+                        {
+                            // Parse legacy octal
+                            if (_pos < _patternEnd)
+                            {
+                                uint v = (uint) (_pattern[_pos] - '0');
+                                if (v <= 7)
+                                {
+                                    cv = (cv << 3) | v;
+                                    _pos++;
+                                    if (cv < 32 && _pos < _patternEnd)
+                                    {
+                                        v = (uint) (_pattern[_pos] - '0');
+                                        if (v <= 7)
+                                        {
+                                            cv = (cv << 3) | v;
+                                            _pos++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        return (int) cv;
+                    }
+
+                default:
+                    return -2;
+            }
+        }
+
+        // Section: Unicode property char check
+
+        private static bool IsUnicodePropertyChar(int c)
+        {
+            return (c >= '0' && c <= '9') ||
+                   (c >= 'A' && c <= 'Z') ||
+                   (c >= 'a' && c <= 'z') ||
+                   c == '_';
+        }
+
+        // Section: Unicode property parsing (port of parse_unicode_property)
+
+        /// <summary>
+        /// Parse \p{...} or \P{...} unicode property escape.
+        /// </summary>
+        private void ParseUnicodeProperty(REStringList cr, bool isInv, bool allowSequenceProp)
+        {
+            if (_pos >= _patternEnd || _pattern[_pos] != '{')
+                throw new RegExpSyntaxException("expecting '{' after \\p");
+            _pos++; // skip '{'
+
+            // Parse property name
+            int nameStart = _pos;
+            while (_pos < _patternEnd && IsUnicodePropertyChar(_pattern[_pos]))
+                _pos++;
+            string name = _pattern.Substring(nameStart, _pos - nameStart);
+
+            // Parse optional value after '='
+            string value = "";
+            if (_pos < _patternEnd && _pattern[_pos] == '=')
+            {
+                _pos++;
+                int valStart = _pos;
+                while (_pos < _patternEnd && IsUnicodePropertyChar(_pattern[_pos]))
+                    _pos++;
+                value = _pattern.Substring(valStart, _pos - valStart);
+            }
+
+            if (_pos >= _patternEnd || _pattern[_pos] != '}')
+                throw new RegExpSyntaxException("expecting '}'");
+            _pos++; // skip '}'
+
+            int ret;
+            if (name is "Script" or "sc")
+            {
+                ret = UnicodeProperties.UnicodeScript(cr.Cr.Points, value, false);
+                if (ret != 0)
+                {
+                    if (ret == -2) throw new RegExpSyntaxException("unknown unicode script");
+                    throw new RegExpSyntaxException("out of memory");
+                }
+            }
+            else if (name is "Script_Extensions" or "scx")
+            {
+                ret = UnicodeProperties.UnicodeScript(cr.Cr.Points, value, true);
+                if (ret != 0)
+                {
+                    if (ret == -2) throw new RegExpSyntaxException("unknown unicode script");
+                    throw new RegExpSyntaxException("out of memory");
+                }
+            }
+            else if (name is "General_Category" or "gc")
+            {
+                ret = UnicodeProperties.UnicodeGeneralCategory(cr.Cr.Points, value);
+                if (ret != 0)
+                {
+                    if (ret == -2) throw new RegExpSyntaxException("unknown unicode general category");
+                    throw new RegExpSyntaxException("out of memory");
+                }
+            }
+            else if (value.Length == 0)
+            {
+                // Try general category first, then binary property, then sequence property
+                ret = UnicodeProperties.UnicodeGeneralCategory(cr.Cr.Points, name);
+                if (ret == -1) throw new RegExpSyntaxException("out of memory");
+                if (ret < 0)
+                {
+                    ret = UnicodeProperties.UnicodeProp(cr.Cr.Points, name);
+                    if (ret == -1) throw new RegExpSyntaxException("out of memory");
+                }
+                if (ret < 0 && !isInv && allowSequenceProp)
+                {
+                    // Use a separate temp list for SeqProp1's internal work.
+                    // SeqProp1 uses the list as a scratch buffer (UnicodeProp1 + Clear),
+                    // so it must NOT be cr.Cr.Points which accumulates our output.
+                    var tempBuf = new List<uint>();
+                    ret = UnicodeProperties.UnicodeSequenceProp(name, (seq, len) =>
+                    {
+                        cr.Add(seq.AsSpan(0, len).ToArray());
+                    }, tempBuf);
+                    if (ret == -1) throw new RegExpSyntaxException("out of memory");
+                }
+                if (ret < 0) throw new RegExpSyntaxException("unknown unicode property name");
+            }
+            else
+            {
+                throw new RegExpSyntaxException("unknown unicode property name");
+            }
+
+            // The ordering of case folding and inversion differs with unicode_sets.
+            if (IgnoreCase && UnicodeSets)
+                cr.Canonicalize(IsUnicode);
+            if (isInv)
+                cr.Cr.Invert();
+            if (IgnoreCase && !UnicodeSets)
+                cr.Canonicalize(IsUnicode);
+        }
+
+        // Section: Class string disjunction (\q{...}) (port of parse_class_string_disjunction)
+
+        private void ParseClassStringDisjunction(REStringList cr)
+        {
+            if (_pos >= _patternEnd || _pattern[_pos] != '{')
+                throw new RegExpSyntaxException("expecting '{' after \\q");
+            _pos++; // skip '{'
+
+            var codePoints = new List<uint>();
+
+            for (; ; )
+            {
+                codePoints.Clear();
+                while (_pos < _patternEnd && _pattern[_pos] != '}' && _pattern[_pos] != '|')
+                {
+                    int c = GetClassAtom(null, true);
+                    if (c < 0) throw new RegExpSyntaxException("unexpected end");
+                    codePoints.Add((uint) c);
+                }
+                cr.Add(codePoints.ToArray());
+
+                if (_pos < _patternEnd && _pattern[_pos] == '}') break;
+                _pos++; // skip '|'
+            }
+
+            if (IgnoreCase) cr.Canonicalize(true);
+            _pos++; // skip '}'
+        }
+
+        // Section: Init built-in char range (port of cr_init_char_range)
+
+        private static void InitCharRange(REStringList cr, uint c)
+        {
+            bool invert = (c & 1) != 0;
+            ReadOnlySpan<ushort> table = (c >> 1) switch
+            {
+                0 => CharRangeD,
+                1 => CharRangeS,
+                2 => CharRangeW,
+                _ => throw new InvalidOperationException("Invalid char range class"),
+            };
+
+            int len = table[0];
+            cr.Cr.Clear();
+            for (int i = 0; i < len * 2; i++)
+            {
+                cr.Cr.AddPoint(table[1 + i]);
+            }
+            if (invert) cr.Cr.Invert();
+        }
+
+        // Section: Class atom parsing (port of get_class_atom)
+
+        /// <summary>
+        /// Parse a single atom inside a character class or as a standalone atom.
+        /// Returns the code point value, or CLASS_RANGE_BASE + enum for built-in classes, or -1 on error.
+        /// If cr is non-null, class ranges (like \d, \p{...}) populate it.
+        /// </summary>
+        private int GetClassAtom(REStringList? cr, bool inclass)
+        {
+            if (_pos >= _patternEnd)
+                throw new RegExpSyntaxException("unexpected end");
+
+            int c = _pattern[_pos];
+
+            switch (c)
+            {
+                case '\\':
+                    {
+                        _pos++;
+                        if (_pos >= _patternEnd)
+                            throw new RegExpSyntaxException("unexpected end");
+                        c = _pattern[_pos++];
+                        switch (c)
+                        {
+                            case 'd':
+                                if (cr == null) goto default_escape;
+                                InitCharRange(cr, (uint) CharRangeEnum.Digit);
+                                return (int) (ClassRangeBase + (uint) CharRangeEnum.Digit);
+                            case 'D':
+                                if (cr == null) goto default_escape;
+                                InitCharRange(cr, (uint) CharRangeEnum.NotDigit);
+                                return (int) (ClassRangeBase + (uint) CharRangeEnum.NotDigit);
+                            case 's':
+                                if (cr == null) goto default_escape;
+                                InitCharRange(cr, (uint) CharRangeEnum.Space);
+                                return (int) (ClassRangeBase + (uint) CharRangeEnum.Space);
+                            case 'S':
+                                if (cr == null) goto default_escape;
+                                InitCharRange(cr, (uint) CharRangeEnum.NotSpace);
+                                return (int) (ClassRangeBase + (uint) CharRangeEnum.NotSpace);
+                            case 'w':
+                                if (cr == null) goto default_escape;
+                                InitCharRange(cr, (uint) CharRangeEnum.Word);
+                                return (int) (ClassRangeBase + (uint) CharRangeEnum.Word);
+                            case 'W':
+                                if (cr == null) goto default_escape;
+                                InitCharRange(cr, (uint) CharRangeEnum.NotWord);
+                                return (int) (ClassRangeBase + (uint) CharRangeEnum.NotWord);
+
+                            case 'c':
+                                {
+                                    if (_pos >= _patternEnd)
+                                    {
+                                        if (IsUnicode)
+                                            throw new RegExpSyntaxException("invalid escape sequence in regular expression");
+                                        _pos--;
+                                        return '\\';
+                                    }
+                                    int cc = _pattern[_pos];
+                                    if ((cc >= 'a' && cc <= 'z') ||
+                                        (cc >= 'A' && cc <= 'Z') ||
+                                        (((cc >= '0' && cc <= '9') || cc == '_') &&
+                                         inclass && !IsUnicode))   // Annex B.1.4
+                                    {
+                                        c = cc & 0x1F;
+                                        _pos++;
+                                    }
+                                    else if (IsUnicode)
+                                    {
+                                        throw new RegExpSyntaxException("invalid escape sequence in regular expression");
+                                    }
+                                    else
+                                    {
+                                        // Return '\' and 'c'
+                                        _pos--;
+                                        c = '\\';
+                                    }
+                                    break;
+                                }
+
+                            case '-':
+                                if (!inclass && IsUnicode)
+                                    throw new RegExpSyntaxException("invalid escape sequence in regular expression");
+                                break;
+
+                            case '^':
+                            case '$':
+                            case '\\':
+                            case '.':
+                            case '*':
+                            case '+':
+                            case '?':
+                            case '(':
+                            case ')':
+                            case '[':
+                            case ']':
+                            case '{':
+                            case '}':
+                            case '|':
+                            case '/':
+                                // Always valid to escape these characters
+                                break;
+
+                            case 'p':
+                            case 'P':
+                                if (IsUnicode && cr != null)
+                                {
+                                    ParseUnicodeProperty(cr, c == 'P', UnicodeSets);
+                                    return (int) ClassRangeBase;
+                                }
+                                goto default_escape;
+
+                            case 'q':
+                                if (UnicodeSets && cr != null && inclass)
+                                {
+                                    ParseClassStringDisjunction(cr);
+                                    return (int) ClassRangeBase;
+                                }
+                                goto default_escape;
+
+                            default:
+default_escape:
+                                {
+                                    _pos--; // back up to char after '\'
+                                    int savedPos = _pos;
+                                    int ret = ParseEscape(IsUnicode ? 2 : 0);
+                                    if (ret >= 0)
+                                    {
+                                        return ret;
+                                    }
+                                    else
+                                    {
+                                        _pos = savedPos;
+                                        if (IsUnicode)
+                                        {
+                                            throw new RegExpSyntaxException("invalid escape sequence in regular expression");
+                                        }
+                                        // Non-unicode: just ignore the '\'
+                                        c = _pattern[_pos];
+                                        _pos++;
+                                        goto normal_char_return;
+                                    }
+                                }
+                        }
+                        break;
+                    }
+
+                case '&':
+                case '!':
+                case '#':
+                case '$':
+                case '%':
+                case '*':
+                case '+':
+                case ',':
+                case '.':
+                case ':':
+                case ';':
+                case '<':
+                case '=':
+                case '>':
+                case '?':
+                case '@':
+                case '^':
+                case '`':
+                case '~':
+                    if (UnicodeSets && _pos + 1 < _patternEnd && _pattern[_pos + 1] == c)
+                    {
+                        // Forbidden double characters in unicode-sets mode
+                        throw new RegExpSyntaxException("invalid class set operation in regular expression");
+                    }
+                    goto default;
+
+                case '(':
+                case ')':
+                case '[':
+                case ']':
+                case '{':
+                case '}':
+                case '/':
+                case '-':
+                case '|':
+                    if (UnicodeSets)
+                    {
+                        throw new RegExpSyntaxException("invalid character in class in regular expression");
+                    }
+                    goto default;
+
+                default:
+                    {
+                        // Normal char: read one code point
+                        char ch = _pattern[_pos];
+                        if (char.IsHighSurrogate(ch) && _pos + 1 < _patternEnd && char.IsLowSurrogate(_pattern[_pos + 1]))
+                        {
+                            c = char.ConvertToUtf32(ch, _pattern[_pos + 1]);
+                            _pos += 2;
+                            if (c > 0xFFFF && !IsUnicode)
+                            {
+                                throw new RegExpSyntaxException("malformed unicode char");
+                            }
+                        }
+                        else
+                        {
+                            c = ch;
+                            _pos++;
+                        }
+                        break;
+                    }
+            }
+normal_char_return:
+            return c;
+        }
+
+        // Section: Emit character range (port of re_emit_range)
+
+        private void EmitRange(CharRange cr)
+        {
+            int len = cr.Length / 2;
+            if (len >= 65535)
+                throw new RegExpSyntaxException("too many ranges");
+            if (len == 0)
+            {
+                // Empty range: emit a char that can never match
+                EmitOpU32(RegExpOpcode.Char32, 0xFFFFFFFF);
+            }
+            else
+            {
+                uint high = cr.Points[cr.Length - 1];
+                if (high <= 0xFFFF)
+                {
+                    // Use 16-bit ranges for BMP-only inclusive endpoints
+                    EmitOpU16(IgnoreCase ? RegExpOpcode.RangeI : RegExpOpcode.Range, (ushort) len);
+                    for (int i = 0; i < cr.Length; i += 2)
+                    {
+                        EmitU16((ushort) cr.Points[i]);
+                        EmitU16((ushort) (cr.Points[i + 1] - 1));
+                    }
+                }
+                else
+                {
+                    // Use 32-bit ranges
+                    EmitOpU16(IgnoreCase ? RegExpOpcode.Range32I : RegExpOpcode.Range32, (ushort) len);
+                    for (int i = 0; i < cr.Length; i += 2)
+                    {
+                        EmitU32(cr.Points[i]);
+                        EmitU32(cr.Points[i + 1] - 1);
+                    }
+                }
+            }
+        }
+
+        // Section: Emit string list (port of re_emit_string_list)
+
+        /// <summary>
+        /// Emit bytecode for matching a REStringList (char ranges + multi-char strings).
+        /// For v-flag (unicode-sets) character classes.
+        /// </summary>
+        private void EmitStringList(REStringList sl)
+        {
+            if (sl.StringCount == 0)
+            {
+                // Simple case: only character ranges
+                EmitRange(sl.Cr);
+            }
+            else
+            {
+                // At least one multi-char string present: match the longest ones first
+                var strings = sl.GetStringsSortedByLengthDesc();
+                bool hasEmptyString = sl.HasEmptyString();
+                int n = strings.Count;
+
+                int lastMatchPos = -1;
+                for (int i = 0; i < n; i++)
+                {
+                    var str = strings[i];
+                    bool isLast = !hasEmptyString && sl.Cr.Length == 0 && i == (n - 1);
+
+                    int splitPos = 0;
+                    if (!isLast)
+                        splitPos = EmitOpU32(RegExpOpcode.SplitNextFirst, 0);
+
+                    foreach (uint cp in str)
+                        EmitChar(cp);
+
+                    if (!isLast)
+                    {
+                        lastMatchPos = EmitOpU32(RegExpOpcode.Goto, (uint) lastMatchPos);
+                        PutU32(splitPos, (uint) (_byteCode.Count - (splitPos + 4)));
+                    }
+                }
+
+                if (sl.Cr.Length != 0)
+                {
+                    bool isLast = !hasEmptyString;
+                    int splitPos = 0;
+                    if (!isLast)
+                        splitPos = EmitOpU32(RegExpOpcode.SplitNextFirst, 0);
+                    EmitRange(sl.Cr);
+                    if (!isLast)
+                        PutU32(splitPos, (uint) (_byteCode.Count - (splitPos + 4)));
+                }
+
+                // Patch the 'goto match' chain
+                while (lastMatchPos != -1)
+                {
+                    int nextPos = (int) ReadU32(lastMatchPos);
+                    PutU32(lastMatchPos, (uint) (_byteCode.Count - (lastMatchPos + 4)));
+                    lastMatchPos = nextPos;
+                }
+            }
+        }
+
+        // Section: Nested class parsing (port of re_parse_nested_class)
+
+        /// <summary>
+        /// Parse a class set operand for unicode-sets (v-flag) operations.
+        /// Port of re_parse_class_set_operand.
+        /// </summary>
+        private void ParseClassSetOperand(REStringList cr)
+        {
+            if (_pos < _patternEnd && _pattern[_pos] == '[')
+            {
+                ParseNestedClass(cr);
+            }
+            else
+            {
+                var tmpCr = new REStringList();
+                int c1 = GetClassAtom(tmpCr, true);
+                if (c1 < 0)
+                    throw new RegExpSyntaxException("unexpected end");
+                if (c1 < (int) ClassRangeBase)
+                {
+                    // Single character: create a range
+                    cr.Cr.Clear();
+                    if (IgnoreCase)
+                        c1 = (int) UnicodeProperties.Canonicalize((uint) c1, IsUnicode);
+                    cr.Cr.UnionInterval((uint) c1, (uint) c1);
+                }
+                else
+                {
+                    // Class range result: copy over
+                    cr.Cr.CopyFrom(tmpCr.Cr);
+                    // Also copy any multi-char strings
+                    cr.Op(tmpCr, CharRangeOp.Union);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parse a (possibly nested) character class [...].
+        /// Handles union, intersection (ampersand-ampersand), and subtraction (--) for unicode-sets.
+        /// Port of re_parse_nested_class.
+        /// </summary>
+        private void ParseNestedClass(REStringList cr)
+        {
+            CheckStackOverflow();
+            try
+            {
+                cr.Clear();
+                _pos++; // skip '['
+
+                bool invert = false;
+                if (_pos < _patternEnd && _pattern[_pos] == '^')
+                {
+                    _pos++;
+                    invert = true;
+                }
+
+                bool isFirst = true;
+                while (_pos < _patternEnd && _pattern[_pos] != ']')
+                {
+                    var cr1 = new REStringList();
+                    int c1;
+                    bool rangeHandled = false;
+
+                    if (_pos < _patternEnd && _pattern[_pos] == '[' && UnicodeSets)
+                    {
+                        ParseNestedClass(cr1);
+                        cr.Op(cr1, CharRangeOp.Union);
+                        goto after_class_handling;
+                    }
+
+                    c1 = GetClassAtom(cr1, true);
+                    if (c1 < 0)
+                        throw new RegExpSyntaxException("unexpected end");
+
+                    // Check for range (c1-c2)
+                    if (_pos < _patternEnd && _pattern[_pos] == '-' &&
+                        (_pos + 1 >= _patternEnd || _pattern[_pos + 1] != ']'))
+                    {
+                        bool fallToClassAtom = false;
+
+                        // Check for '--' in unicode_sets mode with first operand
+                        if (_pos + 1 < _patternEnd && _pattern[_pos + 1] == '-' && UnicodeSets && isFirst)
+                        {
+                            fallToClassAtom = true;
+                        }
+                        else if (c1 >= (int) ClassRangeBase)
+                        {
+                            if (IsUnicode)
+                                throw new RegExpSyntaxException("invalid class range");
+                            // Annex B: match '-' character
+                            fallToClassAtom = true;
+                        }
+
+                        if (!fallToClassAtom)
+                        {
+                            int savedPos = _pos;
+                            _pos++; // skip '-'
+                            var cr1b = new REStringList();
+                            int c2 = GetClassAtom(cr1b, true);
+                            if (c2 < 0)
+                                throw new RegExpSyntaxException("unexpected end");
+                            if (c2 >= (int) ClassRangeBase)
+                            {
+                                if (IsUnicode)
+                                    throw new RegExpSyntaxException("invalid class range");
+                                _pos = savedPos;
+                                fallToClassAtom = true;
+                            }
+
+                            if (!fallToClassAtom)
+                            {
+                                if (c2 < c1)
+                                    throw new RegExpSyntaxException("invalid class range");
+
+                                if (IgnoreCase)
+                                {
+                                    var cr2 = new CharRange();
+                                    cr2.AddInterval((uint) c1, (uint) c2 + 1);
+                                    cr2.RegexpCanonicalize(IsUnicode);
+                                    cr.Cr.Op1(cr2, CharRangeOp.Union);
+                                }
+                                else
+                                {
+                                    cr.Cr.UnionInterval((uint) c1, (uint) c2);
+                                }
+                                rangeHandled = true;
+                                isFirst = false;
+                            }
+                        }
+
+                        if (fallToClassAtom)
+                        {
+                            // Emit class atom: union the single char into cr
+                            if (c1 >= 0 && c1 < (int) ClassRangeBase)
+                            {
+                                if (IgnoreCase)
+                                {
+                                    var crTmp = new CharRange();
+                                    crTmp.AddInterval((uint) c1, (uint) c1 + 1);
+                                    crTmp.RegexpCanonicalize(IsUnicode);
+                                    cr.Cr.Op1(crTmp, CharRangeOp.Union);
+                                }
+                                else
+                                {
+                                    cr.Cr.UnionInterval((uint) c1, (uint) c1);
+                                }
+                            }
+                            else
+                            {
+                                // Multi-char class or special class - union ranges AND strings
+                                cr.Op(cr1, CharRangeOp.Union);
+                            }
+                        }
+                    }
+
+                    // If no range was handled, union the single class atom into cr
+                    if (!rangeHandled)
+                    {
+                        if (c1 >= 0 && c1 < (int) ClassRangeBase)
+                        {
+                            if (IgnoreCase)
+                            {
+                                var crTmp = new CharRange();
+                                crTmp.AddInterval((uint) c1, (uint) c1 + 1);
+                                crTmp.RegexpCanonicalize(IsUnicode);
+                                cr.Cr.Op1(crTmp, CharRangeOp.Union);
+                            }
+                            else
+                            {
+                                cr.Cr.UnionInterval((uint) c1, (uint) c1);
+                            }
+                        }
+                        else
+                        {
+                            // Property escape, \d, \w, \q{}, \p{} etc. - union ranges AND strings
+                            cr.Op(cr1, CharRangeOp.Union);
+                        }
+                    }
+
+after_class_handling:
+// Handle unicode-sets operators
+                    if (UnicodeSets && isFirst)
+                    {
+                        if (_pos + 1 < _patternEnd && _pattern[_pos] == '&' &&
+                            _pattern[_pos + 1] == '&' &&
+                            (_pos + 2 >= _patternEnd || _pattern[_pos + 2] != '&'))
+                        {
+                            // Handle '&&' intersection
+                            for (; ; )
+                            {
+                                if (_pos >= _patternEnd || _pattern[_pos] == ']') break;
+                                if (_pattern[_pos] == '&' && _pos + 1 < _patternEnd &&
+                                    _pattern[_pos + 1] == '&' &&
+                                    (_pos + 2 >= _patternEnd || _pattern[_pos + 2] != '&'))
+                                {
+                                    _pos += 2;
+                                }
+                                else
+                                {
+                                    throw new RegExpSyntaxException("invalid operation in regular expression");
+                                }
+                                var operand = new REStringList();
+                                ParseClassSetOperand(operand);
+                                cr.Op(operand, CharRangeOp.Inter);
+                            }
+                        }
+                        else if (_pos + 1 < _patternEnd && _pattern[_pos] == '-' &&
+                                 _pattern[_pos + 1] == '-')
+                        {
+                            // Handle '--' subtraction
+                            for (; ; )
+                            {
+                                if (_pos >= _patternEnd || _pattern[_pos] == ']') break;
+                                if (_pattern[_pos] == '-' && _pos + 1 < _patternEnd &&
+                                    _pattern[_pos + 1] == '-')
+                                {
+                                    _pos += 2;
+                                }
+                                else
+                                {
+                                    throw new RegExpSyntaxException("invalid operation in regular expression");
+                                }
+                                var operand = new REStringList();
+                                ParseClassSetOperand(operand);
+                                cr.Op(operand, CharRangeOp.Sub);
+                            }
+                        }
+                    }
+                    isFirst = false;
+                }
+
+                if (_pos >= _patternEnd)
+                    throw new RegExpSyntaxException("unterminated character class");
+                _pos++; // skip ']'
+
+                if (invert)
+                {
+                    if (cr.StringCount != 0)
+                    {
+                        throw new RegExpSyntaxException("negated character class with strings in regular expression");
+                    }
+                    cr.Cr.Invert();
+                }
+            }
+            finally
+            {
+                DecrementRecursionDepth();
+            }
+        }
+
+        // Section: Character class entry point (port of re_parse_char_class)
+
+        private void ParseCharClass()
+        {
+            var cr = new REStringList();
+            ParseNestedClass(cr);
+            EmitStringList(cr);
+        }
+
+        // Section: Check advance and capture init (port of re_need_check_adv_and_capture_init)
+
+        [StructLayout(LayoutKind.Auto)]
+        private readonly record struct NeedCheckResult(bool NeedCheckAdv, bool NeedCaptureInit);
+
+        /// <summary>
+        /// Determine if the bytecode atom always advances the character pointer
+        /// and whether captures need initialization.
+        /// </summary>
+        private NeedCheckResult NeedCheckAdvAndCaptureInit(int start, int end)
+        {
+            bool needCheckAdv = true;
+            bool needCaptureInit = false;
+            int pos = start;
+
+            while (pos < end)
+            {
+                var opcode = (RegExpOpcode) _byteCode[pos];
+                int len = RegExpOpcodeInfo.GetSize(opcode);
+
+                switch (opcode)
+                {
+                    case RegExpOpcode.Range:
+                    case RegExpOpcode.RangeI:
+                        len += ReadU16(pos + 1) * 4;
+                        needCheckAdv = false;
+                        break;
+                    case RegExpOpcode.Range32:
+                    case RegExpOpcode.Range32I:
+                        len += ReadU16(pos + 1) * 8;
+                        needCheckAdv = false;
+                        break;
+                    case RegExpOpcode.Char:
+                    case RegExpOpcode.CharI:
+                    case RegExpOpcode.Char32:
+                    case RegExpOpcode.Char32I:
+                    case RegExpOpcode.Dot:
+                    case RegExpOpcode.Any:
+                    case RegExpOpcode.Space:
+                    case RegExpOpcode.NotSpace:
+                        needCheckAdv = false;
+                        break;
+                    case RegExpOpcode.LineStart:
+                    case RegExpOpcode.LineStartM:
+                    case RegExpOpcode.LineEnd:
+                    case RegExpOpcode.LineEndM:
+                    case RegExpOpcode.SetI32:
+                    case RegExpOpcode.SetCharPos:
+                    case RegExpOpcode.WordBoundary:
+                    case RegExpOpcode.WordBoundaryI:
+                    case RegExpOpcode.NotWordBoundary:
+                    case RegExpOpcode.NotWordBoundaryI:
+                    case RegExpOpcode.Prev:
+                    case RegExpOpcode.SaveStart:
+                    case RegExpOpcode.SaveEnd:
+                    case RegExpOpcode.SaveReset:
+                        break;
+                    case RegExpOpcode.BackReference:
+                    case RegExpOpcode.BackReferenceI:
+                    case RegExpOpcode.BackwardBackReference:
+                    case RegExpOpcode.BackwardBackReferenceI:
+                        len += _byteCode[pos + 1];
+                        needCaptureInit = true;
+                        break;
+                    default:
+                        needCaptureInit = true;
+                        goto done;
+                }
+                pos += len;
+            }
+done:
+            return new NeedCheckResult(needCheckAdv, needCaptureInit);
+        }
+
+        // Section: Group name parsing (port of re_parse_group_name)
+
+        /// <summary>
+        /// Parse a group name. _pos points to the first char after '&lt;'.
+        /// Returns the group name string, or throws RegExpSyntaxException.
+        /// </summary>
+        private string ParseGroupName()
+        {
+            var sb = new System.Text.StringBuilder();
+            bool isFirst = true;
+
+            while (_pos < _patternEnd)
+            {
+                int c;
+                if (_pattern[_pos] == '\\')
+                {
+                    _pos++;
+                    if (_pos >= _patternEnd || _pattern[_pos] != 'u')
+                        throw new RegExpSyntaxException("invalid group name");
+                    c = ParseEscape(2); // Accept surrogate pairs
+                    if (c < 0)
+                        throw new RegExpSyntaxException("invalid group name");
+                }
+                else if (_pattern[_pos] == '>')
+                {
+                    break;
+                }
+                else
+                {
+                    c = ReadGroupNameCodePoint();
+                }
+
+                if (c > 0x10FFFF)
+                    throw new RegExpSyntaxException("invalid group name");
+
+                if (isFirst)
+                {
+                    if (!IsIdentFirst(c))
+                        throw new RegExpSyntaxException("invalid group name");
+                    isFirst = false;
+                }
+                else
+                {
+                    if (!IsIdentNext(c))
+                        throw new RegExpSyntaxException("invalid group name");
+                }
+
+                if (c <= 0xFFFF)
+                    sb.Append((char) c);
+                else
+                    sb.Append(char.ConvertFromUtf32(c));
+            }
+
+            if (sb.Length == 0)
+                throw new RegExpSyntaxException("invalid group name");
+            if (_pos >= _patternEnd || _pattern[_pos] != '>')
+                throw new RegExpSyntaxException("invalid group name");
+            _pos++; // skip '>'
+
+            return sb.ToString();
+        }
+
+        private int ReadGroupNameCodePoint()
+        {
+            if (_pos >= _patternEnd) return -1;
+            char ch = _pattern[_pos++];
+            if (char.IsHighSurrogate(ch) && _pos < _patternEnd && char.IsLowSurrogate(_pattern[_pos]))
+            {
+                return char.ConvertToUtf32(ch, _pattern[_pos++]);
+            }
+            return ch;
+        }
+
+        // Section: Identifier character checks (port of lre_js_is_ident_first / lre_js_is_ident_next)
+
+        private static bool IsIdentFirst(int c)
+        {
+            if (c < 128)
+            {
+                return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '$';
+            }
+            // Use .NET Unicode category for non-ASCII
+            if (c > 0xFFFF)
+            {
+                var cat = CharUnicodeInfo.GetUnicodeCategory(char.ConvertFromUtf32(c), 0);
+                return cat is UnicodeCategory.UppercaseLetter or UnicodeCategory.LowercaseLetter
+                    or UnicodeCategory.TitlecaseLetter or UnicodeCategory.ModifierLetter
+                    or UnicodeCategory.OtherLetter or UnicodeCategory.LetterNumber;
+            }
+            return CharUnicodeInfo.GetUnicodeCategory((char) c) is
+                UnicodeCategory.UppercaseLetter or UnicodeCategory.LowercaseLetter
+                or UnicodeCategory.TitlecaseLetter or UnicodeCategory.ModifierLetter
+                or UnicodeCategory.OtherLetter or UnicodeCategory.LetterNumber;
+        }
+
+        private static bool IsIdentNext(int c)
+        {
+            if (c < 128)
+            {
+                return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+                       (c >= '0' && c <= '9') || c == '_' || c == '$';
+            }
+            // ZWNJ and ZWJ are accepted in identifiers
+            if (c is >= 0x200C and <= 0x200D) return true;
+            if (c > 0xFFFF)
+            {
+                var cat = CharUnicodeInfo.GetUnicodeCategory(char.ConvertFromUtf32(c), 0);
+                return cat is UnicodeCategory.UppercaseLetter or UnicodeCategory.LowercaseLetter
+                    or UnicodeCategory.TitlecaseLetter or UnicodeCategory.ModifierLetter
+                    or UnicodeCategory.OtherLetter or UnicodeCategory.LetterNumber
+                    or UnicodeCategory.NonSpacingMark or UnicodeCategory.SpacingCombiningMark
+                    or UnicodeCategory.DecimalDigitNumber or UnicodeCategory.ConnectorPunctuation;
+            }
+            return CharUnicodeInfo.GetUnicodeCategory((char) c) is
+                UnicodeCategory.UppercaseLetter or UnicodeCategory.LowercaseLetter
+                or UnicodeCategory.TitlecaseLetter or UnicodeCategory.ModifierLetter
+                or UnicodeCategory.OtherLetter or UnicodeCategory.LetterNumber
+                or UnicodeCategory.NonSpacingMark or UnicodeCategory.SpacingCombiningMark
+                or UnicodeCategory.DecimalDigitNumber or UnicodeCategory.ConnectorPunctuation;
+        }
+
+        // Section: Capture counting (port of re_parse_captures)
+
+        /// <summary>
+        /// If captureName is null: return the total number of captures + 1.
+        /// Otherwise, return the number of groups matching that name.
+        /// If emitGroupIndex, emit the matching capture indexes into bytecode.
+        /// </summary>
+        private int ParseCaptures(out int hasNamedCaptures, string? captureName, bool emitGroupIndex)
+        {
+            int captureIndex = 1;
+            int n = 0;
+            hasNamedCaptures = 0;
+
+            int p = 0;
+            while (p < _patternEnd)
+            {
+                char ch = _pattern[p];
+                switch (ch)
+                {
+                    case '(':
+                        if (p + 1 < _patternEnd && _pattern[p + 1] == '?')
+                        {
+                            if (p + 3 < _patternEnd && _pattern[p + 2] == '<' &&
+                                _pattern[p + 3] != '=' && _pattern[p + 3] != '!')
+                            {
+                                hasNamedCaptures = 1;
+                                if (captureName != null)
+                                {
+                                    // Find the end of the group name
+                                    int nameStart = p + 3;
+                                    int nameEnd = nameStart;
+                                    while (nameEnd < _patternEnd && _pattern[nameEnd] != '>')
+                                    {
+                                        if (_pattern[nameEnd] == '\\') nameEnd++;
+                                        nameEnd++;
+                                    }
+                                    if (nameEnd < _patternEnd)
+                                    {
+                                        int savedPos = _pos;
+                                        _pos = nameStart;
+                                        try
+                                        {
+                                            string name = ParseGroupName();
+                                            if (string.Equals(name, captureName, StringComparison.Ordinal))
+                                            {
+                                                if (emitGroupIndex)
+                                                    _byteCode.Add((byte) captureIndex);
+                                                n++;
+                                            }
+                                        }
+                                        catch
+                                        {
+                                            // Ignore parse errors during capture counting
+                                        }
+                                        _pos = savedPos;
+                                        p = nameEnd + 1;
+                                    }
+                                }
+                                captureIndex++;
+                                if (captureIndex >= CaptureCountMax) goto done;
+                            }
+                            // Non-capturing groups like (?:...) don't increment
+                        }
+                        else
+                        {
+                            captureIndex++;
+                            if (captureIndex >= CaptureCountMax) goto done;
+                        }
+                        break;
+
+                    case '\\':
+                        p++;
+                        break;
+
+                    case '[':
+                        // Skip to end of character class
+                        p++;
+                        if (p < _patternEnd && _pattern[p] == ']') p++;
+                        while (p < _patternEnd && _pattern[p] != ']')
+                        {
+                            if (_pattern[p] == '\\') p++;
+                            p++;
+                        }
+                        break;
+                }
+                p++;
+            }
+done:
+            return captureName != null ? n : captureIndex;
+        }
+
+        private int CountCaptures()
+        {
+            if (TotalCaptureCount < 0)
+            {
+                TotalCaptureCount = ParseCaptures(out int hnc, null, false);
+                HasNamedCaptures = hnc;
+            }
+            return TotalCaptureCount;
+        }
+
+        private bool HasNamedCapturesDetermined()
+        {
+            if (HasNamedCaptures < 0)
+                CountCaptures();
+            return HasNamedCaptures != 0;
+        }
+
+        // Section: Group name lookup (port of find_group_name)
+
+        /// <summary>
+        /// Find a group name in the already-parsed group names list.
+        /// Returns the count of matching groups. If emitGroupIndex, emits capture indexes.
+        /// </summary>
+        private int FindGroupName(string name, bool emitGroupIndex)
+        {
+            int captureIndex = 1;
+            int n = 0;
+            foreach (var entry in GroupNames)
+            {
+                if (entry.Name != null && string.Equals(entry.Name, name, StringComparison.Ordinal))
+                {
+                    if (emitGroupIndex)
+                        _byteCode.Add((byte) captureIndex);
+                    n++;
+                }
+                captureIndex++;
+            }
+            return n;
+        }
+
+        /// <summary>
+        /// Check if a group name is a duplicate within the same scope.
+        /// Port of is_duplicate_group_name.
+        /// </summary>
+        private bool IsDuplicateGroupName(string name, int scope)
+        {
+            foreach (var entry in GroupNames)
+            {
+                if (entry.Name != null && string.Equals(entry.Name, name, StringComparison.Ordinal) && entry.Scope == scope)
+                    return true;
+            }
+            return false;
+        }
+
+        // Section: Modifier parsing (port of re_parse_modifiers)
+
+        private int ParseModifiers()
+        {
+            int mask = 0;
+            while (_pos < _patternEnd)
+            {
+                int val;
+                char c = _pattern[_pos];
+                if (c == 'i')
+                    val = (int) RegExpFlags.IgnoreCase;
+                else if (c == 'm')
+                    val = (int) RegExpFlags.Multiline;
+                else if (c == 's')
+                    val = (int) RegExpFlags.DotAll;
+                else
+                    break;
+                if ((mask & val) != 0)
+                    throw new RegExpSyntaxException($"duplicate modifier: '{c}'");
+                mask |= val;
+                _pos++;
+            }
+            return mask;
+        }
+
+        private static bool UpdateModifier(bool val, int addMask, int removeMask, int mask)
+        {
+            if ((addMask & mask) != 0) val = true;
+            if ((removeMask & mask) != 0) val = false;
+            return val;
+        }
+
+        // Section: Main parser - re_parse_term
+
+        private void ParseTerm(bool isBackwardDir)
+        {
+            int lastAtomStart = -1;
+            int lastCaptureCount = 0;
+
+            if (_pos >= _patternEnd) return;
+
+            int c = _pattern[_pos];
+
+            switch (c)
+            {
+                case '^':
+                    _pos++;
+                    EmitOp(MultiLine ? RegExpOpcode.LineStartM : RegExpOpcode.LineStart);
+                    break;
+
+                case '$':
+                    _pos++;
+                    EmitOp(MultiLine ? RegExpOpcode.LineEndM : RegExpOpcode.LineEnd);
+                    break;
+
+                case '.':
+                    _pos++;
+                    lastAtomStart = _byteCode.Count;
+                    lastCaptureCount = CaptureCount;
+                    if (isBackwardDir) EmitOp(RegExpOpcode.Prev);
+                    EmitOp(DotAll ? RegExpOpcode.Any : RegExpOpcode.Dot);
+                    if (isBackwardDir) EmitOp(RegExpOpcode.Prev);
+                    break;
+
+                case '{':
+                    if (IsUnicode)
+                    {
+                        throw new RegExpSyntaxException("syntax error");
+                    }
+                    else if (_pos + 1 >= _patternEnd || !IsAsciiDigit(_pattern[_pos + 1]))
+                    {
+                        // Annex B: accept '{' not followed by digits as normal atom
+                        goto parse_class_atom;
+                    }
+                    else
+                    {
+                        // Annex B: error if it looks like a repetition count
+                        int p1 = _pos + 1;
+                        ParseDigitsAt(_pattern, ref p1, _patternEnd, true);
+                        if (p1 < _patternEnd && _pattern[p1] == ',')
+                        {
+                            p1++;
+                            if (p1 < _patternEnd && IsAsciiDigit(_pattern[p1]))
+                                ParseDigitsAt(_pattern, ref p1, _patternEnd, true);
+                        }
+                        if (p1 >= _patternEnd || _pattern[p1] != '}')
+                            goto parse_class_atom;
+                    }
+                    // Fall through to "nothing to repeat"
+                    goto case '*';
+
+                case '*':
+                case '+':
+                case '?':
+                    throw new RegExpSyntaxException("nothing to repeat");
+
+                case '(':
+                    if (_pos + 1 < _patternEnd && _pattern[_pos + 1] == '?')
+                    {
+                        if (_pos + 2 < _patternEnd && _pattern[_pos + 2] == ':')
+                        {
+                            // Non-capturing group (?:...)
+                            _pos += 3;
+                            lastAtomStart = _byteCode.Count;
+                            lastCaptureCount = CaptureCount;
+                            ParseDisjunction(isBackwardDir);
+                            ParseExpect(')');
+                        }
+                        else if (_pos + 2 < _patternEnd &&
+                                 (_pattern[_pos + 2] is 'i' or 'm' or 's' or '-'))
+                        {
+                            // Modifiers group (?ims-ims:...)
+                            _pos += 2;
+                            int addMask = ParseModifiers();
+                            int removeMask = 0;
+                            if (_pos < _patternEnd && _pattern[_pos] == '-')
+                            {
+                                _pos++;
+                                removeMask = ParseModifiers();
+                            }
+                            if ((addMask == 0 && removeMask == 0) || (addMask & removeMask) != 0)
+                                throw new RegExpSyntaxException("invalid modifiers");
+                            ParseExpect(':');
+
+                            bool savedIgnoreCase = IgnoreCase;
+                            bool savedMultiLine = MultiLine;
+                            bool savedDotAll = DotAll;
+
+                            IgnoreCase = UpdateModifier(IgnoreCase, addMask, removeMask, (int) RegExpFlags.IgnoreCase);
+                            MultiLine = UpdateModifier(MultiLine, addMask, removeMask, (int) RegExpFlags.Multiline);
+                            DotAll = UpdateModifier(DotAll, addMask, removeMask, (int) RegExpFlags.DotAll);
+
+                            lastAtomStart = _byteCode.Count;
+                            lastCaptureCount = CaptureCount;
+                            ParseDisjunction(isBackwardDir);
+                            ParseExpect(')');
+
+                            IgnoreCase = savedIgnoreCase;
+                            MultiLine = savedMultiLine;
+                            DotAll = savedDotAll;
+                        }
+                        else if (_pos + 2 < _patternEnd && _pattern[_pos + 2] is '=' or '!')
+                        {
+                            // Lookahead (?=...) or (?!...)
+                            bool isNeg = _pattern[_pos + 2] == '!';
+                            _pos += 3;
+                            EmitLookahead(isNeg, false, isBackwardDir, ref lastAtomStart, ref lastCaptureCount);
+                        }
+                        else if (_pos + 3 < _patternEnd && _pattern[_pos + 2] == '<' &&
+                                 _pattern[_pos + 3] is '=' or '!')
+                        {
+                            // Lookbehind (?<=...) or (?<!...)
+                            bool isNeg = _pattern[_pos + 3] == '!';
+                            _pos += 4;
+                            EmitLookahead(isNeg, true, isBackwardDir, ref lastAtomStart, ref lastCaptureCount);
+                        }
+                        else if (_pos + 2 < _patternEnd && _pattern[_pos + 2] == '<')
+                        {
+                            // Named capture (?<name>...)
+                            _pos += 3;
+                            string groupName = ParseGroupName();
+                            if (IsDuplicateGroupName(groupName, GroupNameScope))
+                                throw new RegExpSyntaxException("duplicate group name");
+                            GroupNames.Add(new GroupNameEntry(groupName, GroupNameScope));
+                            HasNamedCaptures = 1;
+                            EmitCapture(isBackwardDir, ref lastAtomStart, ref lastCaptureCount);
+                        }
+                        else
+                        {
+                            throw new RegExpSyntaxException("invalid group");
+                        }
+                    }
+                    else
+                    {
+                        // Unnamed capture (...)
+                        _pos++; // skip '('
+                        GroupNames.Add(new GroupNameEntry(null, 0));
+                        EmitCapture(isBackwardDir, ref lastAtomStart, ref lastCaptureCount);
+                    }
+                    break;
+
+                case '\\':
+                    if (_pos + 1 >= _patternEnd) goto parse_class_atom;
+                    switch (_pattern[_pos + 1])
+                    {
+                        case 'b':
+                        case 'B':
+                            {
+                                bool isBig = _pattern[_pos + 1] == 'B';
+                                if (isBig)
+                                    EmitOp(IgnoreCase && IsUnicode ? RegExpOpcode.NotWordBoundaryI : RegExpOpcode.NotWordBoundary);
+                                else
+                                    EmitOp(IgnoreCase && IsUnicode ? RegExpOpcode.WordBoundaryI : RegExpOpcode.WordBoundary);
+                                _pos += 2;
+                                break;
+                            }
+
+                        case 'k':
+                            {
+                                int kPos = _pos;
+                                ParseBackReferenceByName(isBackwardDir, ref lastAtomStart, ref lastCaptureCount);
+                                if (_pos == kPos)
+                                {
+                                    // Annex B fallback: treat \k as literal 'k'
+                                    _pos += 2;
+                                    lastAtomStart = _byteCode.Count;
+                                    lastCaptureCount = CaptureCount;
+                                    if (isBackwardDir) EmitOp(RegExpOpcode.Prev);
+                                    EmitChar('k');
+                                    if (isBackwardDir) EmitOp(RegExpOpcode.Prev);
+                                }
+                                break;
+                            }
+
+                        case '0':
+                            {
+                                _pos += 2;
+                                c = 0;
+                                if (IsUnicode)
+                                {
+                                    if (_pos < _patternEnd && IsAsciiDigit(_pattern[_pos]))
+                                        throw new RegExpSyntaxException("invalid decimal escape in regular expression");
+                                }
+                                else
+                                {
+                                    // Annex B: accept legacy octal
+                                    if (_pos < _patternEnd && _pattern[_pos] >= '0' && _pattern[_pos] <= '7')
+                                    {
+                                        c = _pattern[_pos++] - '0';
+                                        if (_pos < _patternEnd && _pattern[_pos] >= '0' && _pattern[_pos] <= '7')
+                                            c = (c << 3) + _pattern[_pos++] - '0';
+                                    }
+                                }
+                                EmitNormalChar(c, null, isBackwardDir, ref lastAtomStart, ref lastCaptureCount);
+                                break;
+                            }
+
+                        case '1':
+                        case '2':
+                        case '3':
+                        case '4':
+                        case '5':
+                        case '6':
+                        case '7':
+                        case '8':
+                        case '9':
+                            {
+                                _pos++; // skip '\'
+                                int qPos = _pos;
+                                c = ParseDigits(false);
+                                if (c < 0 || (c >= CaptureCount && c >= CountCaptures()))
+                                {
+                                    if (!IsUnicode)
+                                    {
+                                        // Annex B: accept legacy octal
+                                        _pos = qPos;
+                                        if (_pos < _patternEnd && _pattern[_pos] <= '7')
+                                        {
+                                            c = 0;
+                                            if (_pattern[_pos] <= '3')
+                                                c = _pattern[_pos++] - '0';
+                                            if (_pos < _patternEnd && _pattern[_pos] >= '0' && _pattern[_pos] <= '7')
+                                            {
+                                                c = (c << 3) + _pattern[_pos++] - '0';
+                                                if (_pos < _patternEnd && _pattern[_pos] >= '0' && _pattern[_pos] <= '7')
+                                                    c = (c << 3) + _pattern[_pos++] - '0';
+                                            }
+                                        }
+                                        else
+                                        {
+                                            c = _pattern[_pos++];
+                                        }
+                                        EmitNormalChar(c, null, isBackwardDir, ref lastAtomStart, ref lastCaptureCount);
+                                        break;
+                                    }
+                                    throw new RegExpSyntaxException("back reference out of range in regular expression");
+                                }
+
+                                lastAtomStart = _byteCode.Count;
+                                lastCaptureCount = CaptureCount;
+                                var brOp = (RegExpOpcode) ((int) RegExpOpcode.BackReference +
+                                                          2 * (isBackwardDir ? 1 : 0) + (IgnoreCase ? 1 : 0));
+                                EmitOpU8(brOp, 1);
+                                _byteCode.Add((byte) c);
+                                break;
+                            }
+
+                        default:
+                            goto parse_class_atom;
+                    }
+                    break;
+
+                case '[':
+                    lastAtomStart = _byteCode.Count;
+                    lastCaptureCount = CaptureCount;
+                    if (isBackwardDir) EmitOp(RegExpOpcode.Prev);
+                    ParseCharClass();
+                    if (isBackwardDir) EmitOp(RegExpOpcode.Prev);
+                    break;
+
+                case ']':
+                case '}':
+                    if (IsUnicode)
+                        throw new RegExpSyntaxException("syntax error");
+                    goto parse_class_atom;
+
+                default:
+parse_class_atom:
+                    {
+                        var crLocal = new REStringList();
+                        c = GetClassAtom(crLocal, false);
+                        if (c < 0) throw new RegExpSyntaxException("unexpected end");
+                        EmitNormalChar(c, crLocal, isBackwardDir, ref lastAtomStart, ref lastCaptureCount);
+                        break;
+                    }
+            }
+
+            // Section: Quantifier parsing
+            ParseQuantifier(lastAtomStart, lastCaptureCount, isBackwardDir);
+        }
+
+        /// <summary>
+        /// Emit a normal character or class atom (extracted from the 'normal_char' label in the C code).
+        /// </summary>
+        private void EmitNormalChar(int c, REStringList? crLocal, bool isBackwardDir,
+                                    ref int lastAtomStart, ref int lastCaptureCount)
+        {
+            lastAtomStart = _byteCode.Count;
+            lastCaptureCount = CaptureCount;
+            if (isBackwardDir) EmitOp(RegExpOpcode.Prev);
+
+            if (c >= (int) ClassRangeBase)
+            {
+                if (c == (int) (ClassRangeBase + (uint) CharRangeEnum.Space))
+                    EmitOp(RegExpOpcode.Space);
+                else if (c == (int) (ClassRangeBase + (uint) CharRangeEnum.NotSpace))
+                    EmitOp(RegExpOpcode.NotSpace);
+                else if (crLocal != null)
+                    EmitStringList(crLocal);
+            }
+            else
+            {
+                if (IgnoreCase)
+                    c = (int) UnicodeProperties.Canonicalize((uint) c, IsUnicode);
+                EmitChar((uint) c);
+            }
+
+            if (isBackwardDir) EmitOp(RegExpOpcode.Prev);
+        }
+
+        // Section: Lookahead emission helper
+
+        private void EmitLookahead(bool isNeg, bool isBackwardLookahead, bool isBackwardDir,
+                                    ref int lastAtomStart, ref int lastCaptureCount)
+        {
+            // Annex B allows lookahead to be used as an atom for quantifiers
+            if (!IsUnicode && !isBackwardLookahead)
+            {
+                lastAtomStart = _byteCode.Count;
+                lastCaptureCount = CaptureCount;
+            }
+
+            var lookaheadOp = isNeg ? RegExpOpcode.NegativeLookahead : RegExpOpcode.Lookahead;
+            int pos = EmitOpU32(lookaheadOp, 0);
+            ParseDisjunction(isBackwardLookahead);
+            ParseExpect(')');
+            var matchOp = isNeg ? RegExpOpcode.NegativeLookaheadMatch : RegExpOpcode.LookaheadMatch;
+            EmitOp(matchOp);
+            // Patch the jump target
+            PutU32(pos, (uint) (_byteCode.Count - (pos + 4)));
+        }
+
+        // Section: Capture emission helper
+
+        private void EmitCapture(bool isBackwardDir, ref int lastAtomStart, ref int lastCaptureCount)
+        {
+            if (CaptureCount >= CaptureCountMax)
+                throw new RegExpSyntaxException("too many captures");
+            lastAtomStart = _byteCode.Count;
+            lastCaptureCount = CaptureCount;
+            int captureIndex = CaptureCount++;
+
+            var saveStartOp = isBackwardDir ? RegExpOpcode.SaveEnd : RegExpOpcode.SaveStart;
+            EmitOpU8(saveStartOp, (byte) captureIndex);
+
+            ParseDisjunction(isBackwardDir);
+
+            var saveEndOp = isBackwardDir ? RegExpOpcode.SaveStart : RegExpOpcode.SaveEnd;
+            EmitOpU8(saveEndOp, (byte) captureIndex);
+
+            ParseExpect(')');
+        }
+
+        // Section: Named backreference parsing (port of \k<name> handling)
+
+        private void ParseBackReferenceByName(bool isBackwardDir,
+                                               ref int lastAtomStart, ref int lastCaptureCount)
+        {
+            if (_pos + 2 >= _patternEnd || _pattern[_pos + 2] != '<')
+            {
+                if (IsUnicode || HasNamedCapturesDetermined())
+                    throw new RegExpSyntaxException("expecting group name");
+                return; // Will be handled by parse_class_atom in the caller
+            }
+
+            int savedPos = _pos;
+            _pos += 3; // skip '\k<'
+            string refName;
+            try
+            {
+                refName = ParseGroupName();
+            }
+            catch
+            {
+                if (IsUnicode || HasNamedCapturesDetermined())
+                    throw new RegExpSyntaxException("invalid group name");
+                _pos = savedPos;
+                return;
+            }
+
+            bool isForward = false;
+            int n = FindGroupName(refName, false);
+            if (n == 0)
+            {
+                // No capture name parsed yet; try forward reference
+                n = ParseCaptures(out _, refName, false);
+                if (n == 0)
+                {
+                    if (IsUnicode || HasNamedCapturesDetermined())
+                        throw new RegExpSyntaxException("group name not defined");
+                    _pos = savedPos;
+                    return;
+                }
+                isForward = true;
+            }
+
+            lastAtomStart = _byteCode.Count;
+            lastCaptureCount = CaptureCount;
+
+            var backRefOp = (RegExpOpcode) ((int) RegExpOpcode.BackReference +
+                                           2 * (isBackwardDir ? 1 : 0) + (IgnoreCase ? 1 : 0));
+            EmitOpU8(backRefOp, (byte) n);
+            if (isForward)
+                ParseCaptures(out _, refName, true);
+            else
+                FindGroupName(refName, true);
+        }
+
+        // Section: Quantifier parsing (extracted from re_parse_term)
+
+        private void ParseQuantifier(int lastAtomStart, int lastCaptureCount, bool isBackwardDir)
+        {
+            if (lastAtomStart < 0 || _pos >= _patternEnd) return;
+
+            int c = _pattern[_pos];
+            int quantMin, quantMax;
+
+            switch (c)
+            {
+                case '*':
+                    _pos++;
+                    quantMin = 0;
+                    quantMax = int.MaxValue;
+                    break;
+                case '+':
+                    _pos++;
+                    quantMin = 1;
+                    quantMax = int.MaxValue;
+                    break;
+                case '?':
+                    _pos++;
+                    quantMin = 0;
+                    quantMax = 1;
+                    break;
+                case '{':
+                    {
+                        int p1 = _pos;
+                        if (_pos + 1 >= _patternEnd || !IsAsciiDigit(_pattern[_pos + 1]))
+                        {
+                            if (IsUnicode)
+                                throw new RegExpSyntaxException("invalid repetition count");
+                            return;
+                        }
+                        _pos++;
+                        quantMin = ParseDigits(true);
+                        quantMax = quantMin;
+                        if (_pos < _patternEnd && _pattern[_pos] == ',')
+                        {
+                            _pos++;
+                            if (_pos < _patternEnd && IsAsciiDigit(_pattern[_pos]))
+                            {
+                                quantMax = ParseDigits(true);
+                                if (quantMax < quantMin)
+                                    throw new RegExpSyntaxException("invalid repetition count");
+                            }
+                            else
+                            {
+                                quantMax = int.MaxValue;
+                            }
+                        }
+                        if (_pos >= _patternEnd || _pattern[_pos] != '}')
+                        {
+                            if (!IsUnicode)
+                            {
+                                // Annex B: normal atom if invalid '{' syntax
+                                _pos = p1;
+                                return;
+                            }
+                        }
+                        ParseExpect('}');
+                        break;
+                    }
+                default:
+                    return;
+            }
+
+            // Check for lazy modifier
+            bool greedy = true;
+            if (_pos < _patternEnd && _pattern[_pos] == '?')
+            {
+                _pos++;
+                greedy = false;
+            }
+
+            var checkResult = NeedCheckAdvAndCaptureInit(lastAtomStart, _byteCode.Count);
+            bool needCaptureInit = checkResult.NeedCaptureInit;
+            bool addZeroAdvanceCheck = checkResult.NeedCheckAdv;
+
+            // Reset captures at each iteration if needed
+            if (needCaptureInit && lastCaptureCount != CaptureCount)
+            {
+                ByteCodeInsert(lastAtomStart, 3);
+                _byteCode[lastAtomStart] = (byte) RegExpOpcode.SaveReset;
+                _byteCode[lastAtomStart + 1] = (byte) lastCaptureCount;
+                _byteCode[lastAtomStart + 2] = (byte) (CaptureCount - 1);
+            }
+
+            int len = _byteCode.Count - lastAtomStart;
+
+            if (quantMin == 0)
+            {
+                // Reset captures if atom is not executed (but only for quant_min==0)
+                if (!needCaptureInit && lastCaptureCount != CaptureCount)
+                {
+                    ByteCodeInsert(lastAtomStart, 3);
+                    _byteCode[lastAtomStart] = (byte) RegExpOpcode.SaveReset;
+                    _byteCode[lastAtomStart + 1] = (byte) lastCaptureCount;
+                    _byteCode[lastAtomStart + 2] = (byte) (CaptureCount - 1);
+                    lastAtomStart += 3;
+                }
+
+                if (quantMax == 0)
+                {
+                    // Remove the atom
+                    _byteCode.RemoveRange(lastAtomStart, _byteCode.Count - lastAtomStart);
+                }
+                else if (quantMax == 1 || quantMax == int.MaxValue)
+                {
+                    bool hasGoto = (quantMax == int.MaxValue);
+                    int insertLen = 5 + (addZeroAdvanceCheck ? 2 : 0);
+                    ByteCodeInsert(lastAtomStart, insertLen);
+
+                    // When goto target is forward (to continuation), greedy means try atom (next) first
+                    _byteCode[lastAtomStart] = (byte) (greedy
+                        ? RegExpOpcode.SplitNextFirst
+                        : RegExpOpcode.SplitGotoFirst);
+                    int jumpDist = len + (hasGoto ? 5 : 0) + (addZeroAdvanceCheck ? 4 : 0);
+                    PutU32(lastAtomStart + 1, (uint) jumpDist);
+
+                    if (addZeroAdvanceCheck)
+                    {
+                        _byteCode[lastAtomStart + 5] = (byte) RegExpOpcode.SetCharPos;
+                        _byteCode[lastAtomStart + 6] = 0;
+                        EmitOpU8(RegExpOpcode.CheckAdvance, 0);
+                    }
+                    if (hasGoto)
+                        EmitGoto(RegExpOpcode.Goto, lastAtomStart);
+                }
+                else
+                {
+                    // Finite quantifier with min=0, max>1
+                    int insertLen = 11 + (addZeroAdvanceCheck ? 2 : 0);
+                    ByteCodeInsert(lastAtomStart, insertLen);
+
+                    int insPos = lastAtomStart;
+                    // When goto target is forward (to continuation), greedy means try atom (next) first
+                    _byteCode[insPos] = (byte) (greedy
+                        ? RegExpOpcode.SplitNextFirst
+                        : RegExpOpcode.SplitGotoFirst);
+                    PutU32(insPos + 1, (uint) (6 + (addZeroAdvanceCheck ? 2 : 0) + len + 10));
+                    insPos += 5;
+
+                    _byteCode[insPos++] = (byte) RegExpOpcode.SetI32;
+                    _byteCode[insPos++] = 0;
+                    PutU32(insPos, (uint) quantMax);
+                    insPos += 4;
+                    lastAtomStart = insPos;
+
+                    if (addZeroAdvanceCheck)
+                    {
+                        _byteCode[insPos++] = (byte) RegExpOpcode.SetCharPos;
+                        _byteCode[insPos] = 0;
+                    }
+
+                    var loopOp = addZeroAdvanceCheck
+                        ? (greedy ? RegExpOpcode.LoopCheckAdvSplitGotoFirst : RegExpOpcode.LoopCheckAdvSplitNextFirst)
+                        : (greedy ? RegExpOpcode.LoopSplitGotoFirst : RegExpOpcode.LoopSplitNextFirst);
+                    EmitGotoU8U32(loopOp, 0, (uint) quantMax, lastAtomStart);
+                }
+            }
+            else if (quantMin == 1 && quantMax == int.MaxValue && !addZeroAdvanceCheck)
+            {
+                // a+ or a+? - simple loop back
+                var splitOp = greedy ? RegExpOpcode.SplitGotoFirst : RegExpOpcode.SplitNextFirst;
+                EmitGoto(splitOp, lastAtomStart);
+            }
+            else
+            {
+                // General case: {n} or {n,m}
+                if (quantMin == quantMax)
+                    addZeroAdvanceCheck = false;
+
+                int insertLen = 6 + (addZeroAdvanceCheck ? 2 : 0);
+                ByteCodeInsert(lastAtomStart, insertLen);
+
+                int insPos = lastAtomStart;
+                _byteCode[insPos++] = (byte) RegExpOpcode.SetI32;
+                _byteCode[insPos++] = 0;
+                PutU32(insPos, (uint) quantMax);
+                insPos += 4;
+                lastAtomStart = insPos;
+
+                if (addZeroAdvanceCheck)
+                {
+                    _byteCode[insPos++] = (byte) RegExpOpcode.SetCharPos;
+                    _byteCode[insPos] = 0;
+                }
+
+                if (quantMin == quantMax)
+                {
+                    // Simple loop: exactly N times
+                    EmitGotoU8(RegExpOpcode.Loop, 0, lastAtomStart);
+                }
+                else
+                {
+                    var loopOp = addZeroAdvanceCheck
+                        ? (greedy ? RegExpOpcode.LoopCheckAdvSplitGotoFirst : RegExpOpcode.LoopCheckAdvSplitNextFirst)
+                        : (greedy ? RegExpOpcode.LoopSplitGotoFirst : RegExpOpcode.LoopSplitNextFirst);
+                    EmitGotoU8U32(loopOp, 0, (uint) (quantMax - quantMin), lastAtomStart);
+                }
+            }
+        }
+
+        // Section: Parse alternative (port of re_parse_alternative)
+
+        private void ParseAlternative(bool isBackwardDir)
+        {
+            int start = _byteCode.Count;
+
+            while (_pos < _patternEnd)
+            {
+                int ch = _pattern[_pos];
+                if (ch == '|' || ch == ')') break;
+
+                int termStart = _byteCode.Count;
+                ParseTerm(isBackwardDir);
+
+                if (isBackwardDir)
+                {
+                    // Reverse the order of the terms (for lookbehind)
+                    int end = _byteCode.Count;
+                    int termSize = end - termStart;
+                    if (termSize > 0 && termStart > start)
+                    {
+                        var termBytes = new byte[termSize];
+                        for (int i = 0; i < termSize; i++)
+                            termBytes[i] = _byteCode[termStart + i];
+                        _byteCode.RemoveRange(termStart, termSize);
+                        _byteCode.InsertRange(start, termBytes);
+                    }
+                }
+            }
+        }
+
+        // Section: Parse disjunction (port of re_parse_disjunction)
+
+        private void ParseDisjunction(bool isBackwardDir)
+        {
+            CheckStackOverflow();
+            try
+            {
+                int start = _byteCode.Count;
+                ParseAlternative(isBackwardDir);
+
+                while (_pos < _patternEnd && _pattern[_pos] == '|')
+                {
+                    _pos++; // skip '|'
+
+                    int len = _byteCode.Count - start;
+
+                    // Insert a split before the first alternative
+                    ByteCodeInsert(start, 5);
+                    _byteCode[start] = (byte) RegExpOpcode.SplitNextFirst;
+                    PutU32(start + 1, (uint) (len + 5));
+
+                    int gotoPos = EmitOpU32(RegExpOpcode.Goto, 0);
+
+                    GroupNameScope++;
+
+                    ParseAlternative(isBackwardDir);
+
+                    // Patch the goto
+                    int newLen = _byteCode.Count - (gotoPos + 4);
+                    PutU32(gotoPos, (uint) newLen);
+                }
+            }
+            finally
+            {
+                DecrementRecursionDepth();
+            }
+        }
+
+        // Section: Register count computation (port of compute_register_count)
+
+        /// <summary>
+        /// Allocate the registers as a stack. The control flow is recursive so
+        /// the analysis can be linear. Returns max stack size or -1 on error.
+        /// </summary>
+        private int ComputeRegisterCount()
+        {
+            int stackSize = 0;
+            int stackSizeMax = 0;
+            int pos = RegExpHeader.Length;
+            int bcLen = _byteCode.Count;
+
+            while (pos < bcLen)
+            {
+                var opcode = (RegExpOpcode) _byteCode[pos];
+                int len = RegExpOpcodeInfo.GetSize(opcode);
+
+                switch (opcode)
+                {
+                    case RegExpOpcode.SetI32:
+                    case RegExpOpcode.SetCharPos:
+                        _byteCode[pos + 1] = (byte) stackSize;
+                        stackSize++;
+                        if (stackSize > stackSizeMax)
+                        {
+                            if (stackSize > RegisterCountMax)
+                                return -1;
+                            stackSizeMax = stackSize;
+                        }
+                        break;
+
+                    case RegExpOpcode.CheckAdvance:
+                    case RegExpOpcode.Loop:
+                    case RegExpOpcode.LoopSplitGotoFirst:
+                    case RegExpOpcode.LoopSplitNextFirst:
+                        stackSize--;
+                        _byteCode[pos + 1] = (byte) stackSize;
+                        break;
+
+                    case RegExpOpcode.LoopCheckAdvSplitGotoFirst:
+                    case RegExpOpcode.LoopCheckAdvSplitNextFirst:
+                        stackSize -= 2;
+                        _byteCode[pos + 1] = (byte) stackSize;
+                        break;
+
+                    case RegExpOpcode.Range:
+                    case RegExpOpcode.RangeI:
+                        len += ReadU16(pos + 1) * 4;
+                        break;
+
+                    case RegExpOpcode.Range32:
+                    case RegExpOpcode.Range32I:
+                        len += ReadU16(pos + 1) * 8;
+                        break;
+
+                    case RegExpOpcode.BackReference:
+                    case RegExpOpcode.BackReferenceI:
+                    case RegExpOpcode.BackwardBackReference:
+                    case RegExpOpcode.BackwardBackReferenceI:
+                        len += _byteCode[pos + 1];
+                        break;
+                }
+                pos += len;
+            }
+            return stackSizeMax;
+        }
+
+        // Section: Group name serialization
+
+        /// <summary>
+        /// Serialize group names to the end of the bytecode buffer.
+        /// Format: null-terminated name + scope byte for each capture group (1-based).
+        /// </summary>
+        private void SerializeGroupNames()
+        {
+            foreach (var entry in GroupNames)
+            {
+                if (entry.Name is { Length: > 0 })
+                {
+                    byte[] nameBytes = System.Text.Encoding.UTF8.GetBytes(entry.Name);
+                    _byteCode.AddRange(nameBytes);
+                }
+                _byteCode.Add(0); // null terminator
+                _byteCode.Add(entry.Scope);
+            }
+        }
+    }
+}
diff --git a/Jint/Runtime/RegExp/RegExpInterpreter.cs b/Jint/Runtime/RegExp/RegExpInterpreter.cs
new file mode 100644
index 0000000000..3244a80b33
--- /dev/null
+++ b/Jint/Runtime/RegExp/RegExpInterpreter.cs
@@ -0,0 +1,1314 @@
+// IDE0055: formatting rules conflict with try/finally wrapping a pre-existing ~600 line while loop
+#pragma warning disable IDE0055
+
+// Ported from QuickJS libregexp.c - Bytecode Interpreter
+//
+// Copyright (c) 2017-2018 Fabrice Bellard
+//
+// 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.
+
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using Jint.Runtime.RegExp.Unicode;
+
+namespace Jint.Runtime.RegExp;
+
+/// <summary>
+/// Bytecode interpreter for QuickJS-compiled regular expressions.
+/// Executes a backtracking NFA over a UTF-16 input string.
+/// </summary>
+internal static class RegExpInterpreter
+{
+    /// <summary>Unset capture position sentinel (mirrors NULL in the C code).</summary>
+    private const int Unset = -1;
+
+    /// <summary>Number of opcodes between cancellation checks.</summary>
+    private const int InterruptCounterInit = 10000;
+
+    /// <summary>Initial backtracking stack capacity (in int elements).</summary>
+    private const int InitialStackCapacity = 128;
+
+    /// <summary>
+    /// Maximum backtracking stack size (in int elements).
+    /// Guards against unbounded memory growth from a single regex execution.
+    /// 16M elements = ~64 MB. Greedy quantifiers on large Unicode strings (e.g. /^\D+$/v
+    /// on 1M chars) legitimately need ~5M elements. The cancellation token timeout
+    /// is the primary ReDoS protection; this limit is a memory safety bound.
+    /// </summary>
+    private const int MaxStackCapacity = 16 * 1024 * 1024;
+
+    // -----------------------------------------------------------------------
+    //  Public API
+    // -----------------------------------------------------------------------
+
+    /// <summary>
+    /// Execute regex bytecode against input string.
+    /// Returns capture positions array on match, null on no match.
+    /// Capture positions: even indices = start char index, odd = end char index.
+    /// Value of -1 means the capture group did not participate.
+    /// </summary>
+    public static int[]? Execute(
+        ReadOnlySpan<byte> bytecode,
+        string input,
+        int startIndex,
+        CancellationToken cancellationToken = default)
+    {
+        var flags = GetFlags(bytecode);
+        int captureCount = bytecode[RegExpHeader.OffsetCaptureCount];
+        int registerCount = bytecode[RegExpHeader.OffsetRegisterCount];
+        bool isUnicode = (flags & (RegExpFlags.Unicode | RegExpFlags.UnicodeSets)) != RegExpFlags.None;
+
+        int allocCount = captureCount * 2 + registerCount;
+
+        // Capture array: indices 0..captureCount*2-1 are capture start/end pairs,
+        // indices captureCount*2..allocCount-1 are registers (loop counters, char positions).
+        int[]? capturePooled = null;
+        Span<int> capture = allocCount <= 64
+            ? stackalloc int[allocCount]
+            : (capturePooled = ArrayPool<int>.Shared.Rent(allocCount)).AsSpan(0, allocCount);
+
+        capture.Fill(Unset);
+
+        int bytecodeLen = BinaryPrimitives.ReadInt32LittleEndian(bytecode.Slice(RegExpHeader.OffsetBytecodeLen));
+        var bc = bytecode.Slice(RegExpHeader.Length, bytecodeLen);
+
+        // Adjust startIndex for surrogate pairs in Unicode mode:
+        // if startIndex lands on the low surrogate of a pair, back up to the high surrogate.
+        int cindex = startIndex;
+        if (cindex > 0 && cindex < input.Length && isUnicode)
+        {
+            if (char.IsLowSurrogate(input[cindex]) && char.IsHighSurrogate(input[cindex - 1]))
+            {
+                cindex--;
+            }
+        }
+
+        try
+        {
+            int ret = ExecBacktrack(bc, input, capture, cindex, captureCount, isUnicode, cancellationToken);
+
+            int[]? result = null;
+            if (ret == 1)
+            {
+                result = new int[captureCount * 2];
+                capture.Slice(0, captureCount * 2).CopyTo(result);
+            }
+
+            return result;
+        }
+        finally
+        {
+            if (capturePooled is not null)
+            {
+                ArrayPool<int>.Shared.Return(capturePooled);
+            }
+        }
+    }
+
+    /// <summary>Get capture count from bytecode header.</summary>
+    public static int GetCaptureCount(ReadOnlySpan<byte> bytecode)
+    {
+        return bytecode[RegExpHeader.OffsetCaptureCount];
+    }
+
+    /// <summary>Get flags from bytecode header.</summary>
+    public static RegExpFlags GetFlags(ReadOnlySpan<byte> bytecode)
+    {
+        return (RegExpFlags) BinaryPrimitives.ReadUInt16LittleEndian(
+            bytecode.Slice(RegExpHeader.OffsetFlags));
+    }
+
+    /// <summary>
+    /// Get group names from bytecode (stored after the bytecode body).
+    /// Returns null if no named groups. Otherwise returns an array of length captureCount
+    /// where index 0 is always null (group 0 = entire match) and subsequent entries are the
+    /// names for groups 1..captureCount-1. A null entry means the group is unnamed.
+    /// </summary>
+    public static string?[]? GetGroupNames(ReadOnlySpan<byte> bytecode)
+    {
+        var flags = GetFlags(bytecode);
+        if ((flags & RegExpFlags.NamedGroups) == RegExpFlags.None)
+        {
+            return null;
+        }
+
+        int captureCount = bytecode[RegExpHeader.OffsetCaptureCount];
+        int bytecodeLen = BinaryPrimitives.ReadInt32LittleEndian(
+            bytecode.Slice(RegExpHeader.OffsetBytecodeLen));
+        int offset = RegExpHeader.Length + bytecodeLen;
+
+        var names = new string?[captureCount];
+        // Group 0 (entire match) has no name. Groups 1..captureCount-1 follow sequentially.
+        for (int i = 1; i < captureCount; i++)
+        {
+            if (offset >= bytecode.Length)
+            {
+                break;
+            }
+
+            // Each name is a NUL-terminated UTF-8 string.
+            int end = offset;
+            while (end < bytecode.Length && bytecode[end] != 0)
+            {
+                end++;
+            }
+
+            if (end > offset)
+            {
+#if NETSTANDARD2_0 || NET462
+                names[i] = Encoding.UTF8.GetString(bytecode.Slice(offset, end - offset).ToArray());
+#else
+                names[i] = Encoding.UTF8.GetString(bytecode.Slice(offset, end - offset));
+#endif
+            }
+
+            // Skip past NUL terminator + 1 byte scope trailer (LRE_GROUP_NAME_TRAILER_LEN = 2 total)
+            offset = end + 1;
+            if (offset < bytecode.Length)
+            {
+                offset++; // skip the trailer byte (group index)
+            }
+        }
+
+        return names;
+    }
+
+    // -----------------------------------------------------------------------
+    //  Backtracking state types (mirrors REExecStateEnum in the C code)
+    // -----------------------------------------------------------------------
+
+    private enum ExecStateType
+    {
+        Split = 0,
+        Lookahead = 1,
+        NegativeLookahead = 2,
+    }
+
+    // -----------------------------------------------------------------------
+    //  Backtracking stack helpers
+    //
+    //  The stack stores frames of 3 ints:
+    //    [sp-3] = saved pc (bytecode offset)
+    //    [sp-2] = saved cindex (string position)
+    //    [sp-1] = packed (bp_offset << 2 | state_type)
+    //
+    //  Between frames, capture-save pairs are stored:
+    //    [sp-2] = capture index
+    //    [sp-1] = old capture value
+    // -----------------------------------------------------------------------
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int PackBpType(int bpOffset, ExecStateType type)
+    {
+        return (bpOffset << 2) | (int) type;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int UnpackBp(int packed) => packed >>> 2;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ExecStateType UnpackType(int packed) => (ExecStateType) (packed & 3);
+
+    // -----------------------------------------------------------------------
+    //  Character access helpers (UTF-16 with optional surrogate pair handling)
+    // -----------------------------------------------------------------------
+
+    /// <summary>Read one code point at cindex, advance cindex past it.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int GetChar(string input, ref int cindex, int end, bool isUnicode)
+    {
+        int c = input[cindex++];
+        if (isUnicode && char.IsHighSurrogate((char) c) && cindex < end && char.IsLowSurrogate(input[cindex]))
+        {
+            c = char.ConvertToUtf32((char) c, input[cindex++]);
+        }
+        return c;
+    }
+
+    /// <summary>Peek one code point at cindex without advancing.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int PeekChar(string input, int cindex, int end, bool isUnicode)
+    {
+        int c = input[cindex];
+        if (isUnicode && char.IsHighSurrogate((char) c) && cindex + 1 < end && char.IsLowSurrogate(input[cindex + 1]))
+        {
+            c = char.ConvertToUtf32((char) c, input[cindex + 1]);
+        }
+        return c;
+    }
+
+    /// <summary>Peek one code point immediately before cindex (looking backward).</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int PeekPrevChar(string input, int cindex, bool isUnicode)
+    {
+        int c = input[cindex - 1];
+        if (isUnicode && char.IsLowSurrogate((char) c) && cindex >= 2 && char.IsHighSurrogate(input[cindex - 2]))
+        {
+            c = char.ConvertToUtf32(input[cindex - 2], (char) c);
+        }
+        return c;
+    }
+
+    /// <summary>Read one code point going backward: decrement cindex, return the code point.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int GetPrevChar(string input, ref int cindex, bool isUnicode)
+    {
+        cindex--;
+        int c = input[cindex];
+        if (isUnicode && char.IsLowSurrogate((char) c) && cindex >= 1 && char.IsHighSurrogate(input[cindex - 1]))
+        {
+            cindex--;
+            c = char.ConvertToUtf32(input[cindex], (char) c);
+        }
+        return c;
+    }
+
+    /// <summary>Move cindex backward by one code point without returning it.</summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void PrevChar(string input, ref int cindex, bool isUnicode)
+    {
+        cindex--;
+        if (isUnicode && cindex > 0 && char.IsLowSurrogate(input[cindex]) && char.IsHighSurrogate(input[cindex - 1]))
+        {
+            cindex--;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    //  Unicode / character classification helpers
+    // -----------------------------------------------------------------------
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsLineTerminator(int c)
+    {
+        return c == '\n' || c == '\r' || c == 0x2028 || c == 0x2029;
+    }
+
+    /// <summary>
+    /// ECMAScript WhiteSpace + LineTerminator test (matches \s character class).
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsSpace(int c)
+    {
+        if ((uint) c <= 0xFF)
+        {
+            // Fast path: tab(9)..cr(13), space(32), nbsp(160)
+            return c is (>= 0x09 and <= 0x0D) or 0x20 or 0xA0;
+        }
+
+        return IsSpaceNonAscii(c);
+    }
+
+    private static bool IsSpaceNonAscii(int c)
+    {
+        return c is 0x1680
+            or (>= 0x2000 and <= 0x200A)
+            or 0x2028 or 0x2029
+            or 0x202F
+            or 0x205F
+            or 0x3000
+            or 0xFEFF;
+    }
+
+    /// <summary>
+    /// Test if c is a word character ([A-Za-z0-9_]) for \b / \w matching.
+    /// Only checks the ASCII-like range; the caller handles special Unicode cases
+    /// (0x017F and 0x212A) for case-insensitive word boundaries separately.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static bool IsWordChar(int c)
+    {
+        if ((uint) c < 128)
+        {
+            return c is (>= 'A' and <= 'Z') or (>= 'a' and <= 'z') or (>= '0' and <= '9') or '_';
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// JavaScript regex case-folding (lre_canonicalize equivalent).
+    /// Unicode mode: simple case fold (upper -> lower for ASCII, CaseFolding for rest).
+    /// Non-Unicode mode: legacy behavior (lower -> upper for ASCII, toUpperCase for rest if single char and >= 128).
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int Canonicalize(int c, bool isUnicode)
+    {
+        if (c < 128)
+        {
+            if (isUnicode)
+            {
+                if (c >= 'A' && c <= 'Z')
+                {
+                    return c - 'A' + 'a';
+                }
+            }
+            else
+            {
+                if (c >= 'a' && c <= 'z')
+                {
+                    return c - 'a' + 'A';
+                }
+            }
+            return c;
+        }
+
+        return CanonicalizeSlow(c, isUnicode);
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static int CanonicalizeSlow(int c, bool isUnicode)
+    {
+        Span<uint> res = stackalloc uint[3];
+        if (isUnicode)
+        {
+            // Simple case fold (convType=2)
+            int len = UnicodeProperties.CaseConv(res, (uint) c, 2);
+            if (len == 1)
+            {
+                return (int) res[0];
+            }
+            // Multi-character case fold special cases
+            return c switch
+            {
+                0xFB06 => 0xFB05,
+                0x1FD3 => 0x0390,
+                0x1FE3 => 0x03B0,
+                _ => c,
+            };
+        }
+        else
+        {
+            // Legacy non-unicode: to upper case if single char result >= 128
+            int len = UnicodeProperties.CaseConv(res, (uint) c, 0);
+            if (len == 1 && res[0] >= 128)
+            {
+                return (int) res[0];
+            }
+            return c;
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    //  Bytecode reading helpers
+    // -----------------------------------------------------------------------
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ushort ReadU16(ReadOnlySpan<byte> bc, int offset)
+    {
+        return BinaryPrimitives.ReadUInt16LittleEndian(bc.Slice(offset));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int ReadI32(ReadOnlySpan<byte> bc, int offset)
+    {
+        return BinaryPrimitives.ReadInt32LittleEndian(bc.Slice(offset));
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static uint ReadU32(ReadOnlySpan<byte> bc, int offset)
+    {
+        return BinaryPrimitives.ReadUInt32LittleEndian(bc.Slice(offset));
+    }
+
+    // -----------------------------------------------------------------------
+    //  Range matching helpers (binary search over sorted interval pairs)
+    // -----------------------------------------------------------------------
+
+    /// <summary>
+    /// Binary search over n sorted 16-bit (low, high) pairs starting at bc[pc].
+    /// Returns true if c falls within any range. 0xFFFF in the last high means +infinity.
+    /// </summary>
+    private static bool MatchRange16(ReadOnlySpan<byte> bc, int pc, int n, uint c)
+    {
+        // 16-bit ranges only cover BMP (U+0000..U+FFFF); supplementary code points
+        // are handled by Range32/Range32I opcodes via MatchRange32.
+        if (c > 0xFFFF)
+        {
+            return false;
+        }
+
+        uint idxMin = 0;
+        uint low = ReadU16(bc, pc);
+        if (c < low)
+        {
+            return false;
+        }
+        uint idxMax = (uint) (n - 1);
+        uint high = ReadU16(bc, pc + (int) idxMax * 4 + 2);
+        if (c > high)
+        {
+            return false;
+        }
+        while (idxMin <= idxMax)
+        {
+            uint idx = (idxMin + idxMax) / 2;
+            low = ReadU16(bc, pc + (int) idx * 4);
+            high = ReadU16(bc, pc + (int) idx * 4 + 2);
+            if (c < low)
+            {
+                if (idx == 0)
+                {
+                    return false;
+                }
+                idxMax = idx - 1;
+            }
+            else if (c > high)
+            {
+                idxMin = idx + 1;
+            }
+            else
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Binary search over n sorted 32-bit (low, high) pairs starting at bc[pc].
+    /// Returns true if c falls within any range.
+    /// </summary>
+    private static bool MatchRange32(ReadOnlySpan<byte> bc, int pc, int n, uint c)
+    {
+        uint idxMin = 0;
+        uint low = ReadU32(bc, pc);
+        if (c < low)
+        {
+            return false;
+        }
+        uint idxMax = (uint) (n - 1);
+        uint high = ReadU32(bc, pc + (int) idxMax * 8 + 4);
+        if (c > high)
+        {
+            return false;
+        }
+        while (idxMin <= idxMax)
+        {
+            uint idx = (idxMin + idxMax) / 2;
+            low = ReadU32(bc, pc + (int) idx * 8);
+            high = ReadU32(bc, pc + (int) idx * 8 + 4);
+            if (c < low)
+            {
+                if (idx == 0)
+                {
+                    return false;
+                }
+                idxMax = idx - 1;
+            }
+            else if (c > high)
+            {
+                idxMin = idx + 1;
+            }
+            else
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // -----------------------------------------------------------------------
+    //  Stack management
+    // -----------------------------------------------------------------------
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void EnsureStackSpace(ref int[] stackBuf, ref int[]? stackPooled, int sp, int needed)
+    {
+        if (sp + needed > stackBuf.Length)
+        {
+            GrowStack(ref stackBuf, ref stackPooled, sp, sp + needed);
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void GrowStack(ref int[] stackBuf, ref int[]? stackPooled, int usedCount, int minCapacity)
+    {
+        if (minCapacity > MaxStackCapacity)
+        {
+            ThrowStackOverflow();
+        }
+
+        int newSize = stackBuf.Length * 3 / 2;
+        if (newSize < minCapacity)
+        {
+            newSize = minCapacity;
+        }
+
+        int[] newBuf = ArrayPool<int>.Shared.Rent(newSize);
+        stackBuf.AsSpan(0, usedCount).CopyTo(newBuf);
+
+        if (stackPooled is not null)
+        {
+            ArrayPool<int>.Shared.Return(stackPooled);
+        }
+
+        stackBuf = newBuf;
+        stackPooled = newBuf;
+    }
+
+    /// <summary>
+    /// Push a backtracking frame: saves the full capture+register array (snapshot approach).
+    /// This matches QuickJS's push_state which does memcpy of the entire capture array.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void PushFrame(
+        ref int[] stackBuf,
+        ref int[]? stackPooled,
+        ref int sp,
+        ref int bp,
+        Span<int> capture,
+        int allocCount,
+        int savedPc,
+        int savedCindex,
+        ExecStateType stateType)
+    {
+        int frameSize = 3 + allocCount;
+        EnsureStackSpace(ref stackBuf, ref stackPooled, sp, frameSize);
+        // Header
+        stackBuf[sp] = savedPc;
+        stackBuf[sp + 1] = savedCindex;
+        stackBuf[sp + 2] = PackBpType(bp, stateType);
+        // Full snapshot of captures + registers
+        for (int i = 0; i < allocCount; i++)
+        {
+            stackBuf[sp + 3 + i] = capture[i];
+        }
+        sp += frameSize;
+        bp = sp;
+    }
+
+    /// <summary>
+    /// Pop a backtracking frame: restores the full capture+register array from snapshot.
+    /// Returns the frame's state type.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static ExecStateType PopFrame(
+        int[] stackBuf,
+        ref int sp,
+        ref int bp,
+        Span<int> capture,
+        int allocCount,
+        out int restoredPc,
+        out int restoredCindex)
+    {
+        int frameSize = 3 + allocCount;
+        sp -= frameSize;
+        restoredPc = stackBuf[sp];
+        restoredCindex = stackBuf[sp + 1];
+        int packed = stackBuf[sp + 2];
+        var stateType = UnpackType(packed);
+        bp = UnpackBp(packed);
+        // Restore full snapshot
+        for (int i = 0; i < allocCount; i++)
+        {
+            capture[i] = stackBuf[sp + 3 + i];
+        }
+        return stateType;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void ReturnStack(int[]? stackPooled)
+    {
+        if (stackPooled is not null)
+        {
+            ArrayPool<int>.Shared.Return(stackPooled);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    //  Main backtracking interpreter (lre_exec_backtrack equivalent)
+    // -----------------------------------------------------------------------
+
+    /// <summary>
+    /// Execute the backtracking NFA interpreter.
+    /// Returns 1 on match, 0 on no match.
+    /// Throws <see cref="OperationCanceledException"/> on timeout/cancellation.
+    /// </summary>
+    private static int ExecBacktrack(
+        ReadOnlySpan<byte> bc,
+        string input,
+        Span<int> capture,
+        int cindex,
+        int captureCount,
+        bool isUnicode,
+        CancellationToken cancellationToken)
+    {
+        int inputEnd = input.Length;
+        int allocCount = capture.Length; // captures + registers
+
+        // Frame size: 3 (header: pc, cindex, packedBp) + allocCount (full snapshot)
+        int frameSize = 3 + allocCount;
+
+        // Backtracking stack (pooled)
+        int[]? stackPooled = ArrayPool<int>.Shared.Rent(InitialStackCapacity);
+        int[] stackBuf = stackPooled;
+        int sp = 0;  // stack pointer (next free index)
+        int bp = 0;  // backtrack pointer (start of current frame's snapshot area, unused in new design but kept for frame nesting)
+
+        int pc = 0;  // program counter (index into bc)
+        int interruptCounter = InterruptCounterInit;
+
+        try {
+        while (true)
+        {
+            var opcode = (RegExpOpcode) bc[pc++];
+
+            switch (opcode)
+            {
+                // ---------------------------------------------------------
+                //  Match / terminal
+                // ---------------------------------------------------------
+                case RegExpOpcode.Match:
+                    {
+                        return 1;
+                    }
+
+                // ---------------------------------------------------------
+                //  Character matching
+                // ---------------------------------------------------------
+                case RegExpOpcode.Char32:
+                case RegExpOpcode.Char32I:
+                    {
+                        uint val = ReadU32(bc, pc);
+                        pc += 4;
+                        if (cindex >= inputEnd)
+                        {
+                            goto noMatch;
+                        }
+                        int c = GetChar(input, ref cindex, inputEnd, isUnicode);
+                        if (opcode == RegExpOpcode.Char32I)
+                        {
+                            c = Canonicalize(c, isUnicode);
+                        }
+                        if (val != (uint) c)
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.Char:
+                case RegExpOpcode.CharI:
+                    {
+                        uint val = ReadU16(bc, pc);
+                        pc += 2;
+                        if (cindex >= inputEnd)
+                        {
+                            goto noMatch;
+                        }
+                        int c = GetChar(input, ref cindex, inputEnd, isUnicode);
+                        if (opcode == RegExpOpcode.CharI)
+                        {
+                            c = Canonicalize(c, isUnicode);
+                        }
+                        if (val != (uint) c)
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.Dot:
+                    {
+                        if (cindex >= inputEnd)
+                        {
+                            goto noMatch;
+                        }
+                        int c = GetChar(input, ref cindex, inputEnd, isUnicode);
+                        if (IsLineTerminator(c))
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.Any:
+                    {
+                        if (cindex >= inputEnd)
+                        {
+                            goto noMatch;
+                        }
+                        GetChar(input, ref cindex, inputEnd, isUnicode);
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Character classes: \s, \S
+                // ---------------------------------------------------------
+                case RegExpOpcode.Space:
+                    {
+                        if (cindex >= inputEnd)
+                        {
+                            goto noMatch;
+                        }
+                        int c = GetChar(input, ref cindex, inputEnd, isUnicode);
+                        if (!IsSpace(c))
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.NotSpace:
+                    {
+                        if (cindex >= inputEnd)
+                        {
+                            goto noMatch;
+                        }
+                        int c = GetChar(input, ref cindex, inputEnd, isUnicode);
+                        if (IsSpace(c))
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Anchors: ^, $
+                // ---------------------------------------------------------
+                case RegExpOpcode.LineStart:
+                case RegExpOpcode.LineStartM:
+                    {
+                        if (cindex == 0)
+                        {
+                            break;
+                        }
+                        if (opcode == RegExpOpcode.LineStart)
+                        {
+                            goto noMatch;
+                        }
+                        // Multiline: match after line terminator
+                        int c = PeekPrevChar(input, cindex, isUnicode);
+                        if (!IsLineTerminator(c))
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.LineEnd:
+                case RegExpOpcode.LineEndM:
+                    {
+                        if (cindex >= inputEnd)
+                        {
+                            break;
+                        }
+                        if (opcode == RegExpOpcode.LineEnd)
+                        {
+                            goto noMatch;
+                        }
+                        // Multiline: match before line terminator
+                        int c = PeekChar(input, cindex, inputEnd, isUnicode);
+                        if (!IsLineTerminator(c))
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Control flow: goto, split
+                // ---------------------------------------------------------
+                case RegExpOpcode.Goto:
+                    {
+                        int val = ReadI32(bc, pc);
+                        pc += 4 + val;
+                        if (--interruptCounter <= 0)
+                        {
+                            interruptCounter = InterruptCounterInit;
+                            cancellationToken.ThrowIfCancellationRequested();
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.SplitGotoFirst:
+                case RegExpOpcode.SplitNextFirst:
+                    {
+                        int val = ReadI32(bc, pc);
+                        pc += 4;
+
+                        int pc1;
+                        if (opcode == RegExpOpcode.SplitNextFirst)
+                        {
+                            pc1 = pc + val;
+                        }
+                        else
+                        {
+                            pc1 = pc;
+                            pc = pc + val;
+                        }
+
+                        PushFrame(ref stackBuf, ref stackPooled, ref sp, ref bp,
+                            capture, allocCount, pc1, cindex, ExecStateType.Split);
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Lookahead assertions
+                // ---------------------------------------------------------
+                case RegExpOpcode.Lookahead:
+                case RegExpOpcode.NegativeLookahead:
+                    {
+                        int val = ReadI32(bc, pc);
+                        pc += 4;
+
+                        var stateType = opcode == RegExpOpcode.Lookahead
+                            ? ExecStateType.Lookahead
+                            : ExecStateType.NegativeLookahead;
+                        PushFrame(ref stackBuf, ref stackPooled, ref sp, ref bp,
+                            capture, allocCount, pc + val, cindex, stateType);
+                        break;
+                    }
+
+                case RegExpOpcode.LookaheadMatch:
+                    {
+                        // Positive lookahead succeeded. Pop frames until the Lookahead frame.
+                        // Keep current captures (modified by the lookahead body).
+                        // Only restore pc and cindex from the Lookahead frame.
+                        while (true)
+                        {
+                            sp -= frameSize;
+                            int packed = stackBuf[sp + 2];
+                            var type = UnpackType(packed);
+                            if (type == ExecStateType.Lookahead)
+                            {
+                                pc = stackBuf[sp];
+                                cindex = stackBuf[sp + 1];
+                                bp = UnpackBp(packed);
+                                break;
+                            }
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.NegativeLookaheadMatch:
+                    {
+                        // Negative lookahead body matched — meaning the assertion fails.
+                        // Pop frames until the NegativeLookahead frame, restoring captures
+                        // from the NegativeLookahead frame's snapshot.
+                        while (true)
+                        {
+                            sp -= frameSize;
+                            int packed = stackBuf[sp + 2];
+                            var type = UnpackType(packed);
+                            if (type == ExecStateType.NegativeLookahead)
+                            {
+                                for (int i = 0; i < allocCount; i++)
+                                {
+                                    capture[i] = stackBuf[sp + 3 + i];
+                                }
+                                bp = UnpackBp(packed);
+                                break;
+                            }
+                        }
+                        goto noMatch;
+                    }
+
+                // ---------------------------------------------------------
+                //  Capture groups
+                // ---------------------------------------------------------
+                case RegExpOpcode.SaveStart:
+                case RegExpOpcode.SaveEnd:
+                    {
+                        int val = bc[pc++];
+                        int idx = 2 * val + (opcode - RegExpOpcode.SaveStart);
+                        capture[idx] = cindex;
+                        break;
+                    }
+
+                case RegExpOpcode.SaveReset:
+                    {
+                        int val = bc[pc];
+                        int val2 = bc[pc + 1];
+                        pc += 2;
+                        while (val <= val2)
+                        {
+                            capture[2 * val] = Unset;
+                            capture[2 * val + 1] = Unset;
+                            val++;
+                        }
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Registers (loop counters and char positions)
+                // ---------------------------------------------------------
+                case RegExpOpcode.SetI32:
+                    {
+                        int idx = 2 * captureCount + bc[pc];
+                        int val = ReadI32(bc, pc + 1);
+                        pc += 5;
+                        capture[idx] = val;
+                        break;
+                    }
+
+                case RegExpOpcode.Loop:
+                    {
+                        int idx = 2 * captureCount + bc[pc];
+                        int val = ReadI32(bc, pc + 1);
+                        pc += 5;
+
+                        int val2 = capture[idx] - 1;
+                        capture[idx] = val2;
+                        if (val2 != 0)
+                        {
+                            pc += val;
+                            if (--interruptCounter <= 0)
+                            {
+                                interruptCounter = InterruptCounterInit;
+                                cancellationToken.ThrowIfCancellationRequested();
+                            }
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.LoopSplitGotoFirst:
+                case RegExpOpcode.LoopSplitNextFirst:
+                case RegExpOpcode.LoopCheckAdvSplitGotoFirst:
+                case RegExpOpcode.LoopCheckAdvSplitNextFirst:
+                    {
+                        int idx = 2 * captureCount + bc[pc];
+                        uint limit = ReadU32(bc, pc + 1);
+                        int val = ReadI32(bc, pc + 5);
+                        pc += 9;
+
+                        // Decrement the counter
+                        int val2 = capture[idx] - 1;
+                        capture[idx] = val2;
+
+                        if ((uint) val2 > limit)
+                        {
+                            // Counter still above limit -> unconditional loop iteration
+                            pc += val;
+                            if (--interruptCounter <= 0)
+                            {
+                                interruptCounter = InterruptCounterInit;
+                                cancellationToken.ThrowIfCancellationRequested();
+                            }
+                        }
+                        else
+                        {
+                            if ((opcode == RegExpOpcode.LoopCheckAdvSplitGotoFirst ||
+                                 opcode == RegExpOpcode.LoopCheckAdvSplitNextFirst) &&
+                                capture[idx + 1] == cindex &&
+                                (uint) val2 != limit)
+                            {
+                                goto noMatch;
+                            }
+
+                            if (val2 != 0)
+                            {
+                                int pc1;
+                                if (opcode == RegExpOpcode.LoopSplitNextFirst ||
+                                    opcode == RegExpOpcode.LoopCheckAdvSplitNextFirst)
+                                {
+                                    pc1 = pc + val;
+                                }
+                                else
+                                {
+                                    pc1 = pc;
+                                    pc = pc + val;
+                                }
+
+                                PushFrame(ref stackBuf, ref stackPooled, ref sp, ref bp,
+                                    capture, allocCount, pc1, cindex, ExecStateType.Split);
+                            }
+                        }
+                        break;
+                    }
+
+                case RegExpOpcode.SetCharPos:
+                    {
+                        int idx = 2 * captureCount + bc[pc++];
+                        capture[idx] = cindex;
+                        break;
+                    }
+
+                case RegExpOpcode.CheckAdvance:
+                    {
+                        int idx = 2 * captureCount + bc[pc++];
+                        if (capture[idx] == cindex)
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Word boundaries: \b, \B
+                // ---------------------------------------------------------
+                case RegExpOpcode.WordBoundary:
+                case RegExpOpcode.WordBoundaryI:
+                case RegExpOpcode.NotWordBoundary:
+                case RegExpOpcode.NotWordBoundaryI:
+                    {
+                        bool ignoreCase = opcode == RegExpOpcode.WordBoundaryI ||
+                                          opcode == RegExpOpcode.NotWordBoundaryI;
+                        bool isBoundary = opcode == RegExpOpcode.WordBoundary ||
+                                          opcode == RegExpOpcode.WordBoundaryI;
+
+                        // Character before current position
+                        bool v1;
+                        if (cindex == 0)
+                        {
+                            v1 = false;
+                        }
+                        else
+                        {
+                            int c = PeekPrevChar(input, cindex, isUnicode);
+                            v1 = c < 256
+                                ? IsWordChar(c)
+                                : ignoreCase && (c == 0x017F || c == 0x212A);
+                        }
+
+                        // Character at current position
+                        bool v2;
+                        if (cindex >= inputEnd)
+                        {
+                            v2 = false;
+                        }
+                        else
+                        {
+                            int c = PeekChar(input, cindex, inputEnd, isUnicode);
+                            v2 = c < 256
+                                ? IsWordChar(c)
+                                : ignoreCase && (c == 0x017F || c == 0x212A);
+                        }
+
+                        // XOR with isBoundary to get: boundary -> v1^v2 must be true;
+                        // not-boundary -> v1^v2 must be false.
+                        if (v1 ^ v2 ^ isBoundary)
+                        {
+                            goto noMatch;
+                        }
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Back references: \1..\N
+                // ---------------------------------------------------------
+                case RegExpOpcode.BackReference:
+                case RegExpOpcode.BackReferenceI:
+                case RegExpOpcode.BackwardBackReference:
+                case RegExpOpcode.BackwardBackReferenceI:
+                    {
+                        int n = bc[pc++];
+                        int pc1 = pc;
+                        pc += n;
+
+                        for (int i = 0; i < n; i++)
+                        {
+                            int val = bc[pc1 + i];
+                            if (val >= captureCount)
+                            {
+                                goto noMatch;
+                            }
+
+                            int cptr1Start = capture[2 * val];
+                            int cptr1End = capture[2 * val + 1];
+
+                            // Use the first non-empty capture
+                            if (cptr1Start != Unset && cptr1End != Unset)
+                            {
+                                if (opcode == RegExpOpcode.BackReference ||
+                                    opcode == RegExpOpcode.BackReferenceI)
+                                {
+                                    // Forward match
+                                    int cptr1 = cptr1Start;
+                                    while (cptr1 < cptr1End)
+                                    {
+                                        if (cindex >= inputEnd)
+                                        {
+                                            goto noMatch;
+                                        }
+                                        int c1 = GetChar(input, ref cptr1, cptr1End, isUnicode);
+                                        int c2 = GetChar(input, ref cindex, inputEnd, isUnicode);
+                                        if (opcode == RegExpOpcode.BackReferenceI)
+                                        {
+                                            c1 = Canonicalize(c1, isUnicode);
+                                            c2 = Canonicalize(c2, isUnicode);
+                                        }
+                                        if (c1 != c2)
+                                        {
+                                            goto noMatch;
+                                        }
+                                        if (--interruptCounter <= 0)
+                                        {
+                                            interruptCounter = InterruptCounterInit;
+                                            cancellationToken.ThrowIfCancellationRequested();
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    // Backward match (for lookbehind)
+                                    int cptr1 = cptr1End;
+                                    while (cptr1 > cptr1Start)
+                                    {
+                                        if (cindex == 0)
+                                        {
+                                            goto noMatch;
+                                        }
+                                        int c1 = GetPrevChar(input, ref cptr1, isUnicode);
+                                        int c2 = GetPrevChar(input, ref cindex, isUnicode);
+                                        if (opcode == RegExpOpcode.BackwardBackReferenceI)
+                                        {
+                                            c1 = Canonicalize(c1, isUnicode);
+                                            c2 = Canonicalize(c2, isUnicode);
+                                        }
+                                        if (c1 != c2)
+                                        {
+                                            goto noMatch;
+                                        }
+                                        if (--interruptCounter <= 0)
+                                        {
+                                            interruptCounter = InterruptCounterInit;
+                                            cancellationToken.ThrowIfCancellationRequested();
+                                        }
+                                    }
+                                }
+                                break; // Found the first non-empty capture, stop searching
+                            }
+                        }
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Character ranges (16-bit pairs)
+                // ---------------------------------------------------------
+                case RegExpOpcode.Range:
+                case RegExpOpcode.RangeI:
+                    {
+                        int n = ReadU16(bc, pc); // n must be >= 1
+                        pc += 2;
+                        if (cindex >= inputEnd)
+                        {
+                            goto noMatch;
+                        }
+                        int c = GetChar(input, ref cindex, inputEnd, isUnicode);
+                        if (opcode == RegExpOpcode.RangeI)
+                        {
+                            c = Canonicalize(c, isUnicode);
+                        }
+
+                        if (!MatchRange16(bc, pc, n, (uint) c))
+                        {
+                            goto noMatch;
+                        }
+                        pc += 4 * n;
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Character ranges (32-bit pairs)
+                // ---------------------------------------------------------
+                case RegExpOpcode.Range32:
+                case RegExpOpcode.Range32I:
+                    {
+                        int n = ReadU16(bc, pc); // n must be >= 1
+                        pc += 2;
+                        if (cindex >= inputEnd)
+                        {
+                            goto noMatch;
+                        }
+                        int c = GetChar(input, ref cindex, inputEnd, isUnicode);
+                        if (opcode == RegExpOpcode.Range32I)
+                        {
+                            c = Canonicalize(c, isUnicode);
+                        }
+
+                        if (!MatchRange32(bc, pc, n, (uint) c))
+                        {
+                            goto noMatch;
+                        }
+                        pc += 8 * n;
+                        break;
+                    }
+
+                // ---------------------------------------------------------
+                //  Prev (go backward one code point, for lookbehind)
+                // ---------------------------------------------------------
+                case RegExpOpcode.Prev:
+                    {
+                        if (cindex == 0)
+                        {
+                            goto noMatch;
+                        }
+                        PrevChar(input, ref cindex, isUnicode);
+                        break;
+                    }
+
+                default:
+                    ThrowInvalidOpcode(opcode);
+                    break;
+            }
+            continue;
+
+// =============================================================
+//  Backtracking: current path failed
+// =============================================================
+noMatch:
+            while (true)
+            {
+                if (sp == 0)
+                {
+                    // No more backtracking frames - overall failure.
+                    return 0;
+                }
+
+                // Pop frame with full capture+register restore
+                var stateType = PopFrame(stackBuf, ref sp, ref bp, capture, allocCount,
+                    out pc, out cindex);
+
+                // For Lookahead frames we keep unwinding (a lookahead failure
+                // means the inner expression failed, not an alternative to try).
+                // For Split and NegativeLookahead we break to resume execution.
+                if (stateType != ExecStateType.Lookahead)
+                {
+                    break;
+                }
+            }
+
+            // Poll for cancellation after backtracking
+            if (--interruptCounter <= 0)
+            {
+                interruptCounter = InterruptCounterInit;
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+        }
+
+        } finally { ReturnStack(stackPooled); }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void ThrowInvalidOpcode(RegExpOpcode opcode)
+    {
+        throw new InvalidOperationException($"Unknown regex opcode: {opcode} ({(int) opcode})");
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void ThrowStackOverflow()
+    {
+        throw new RegexMatchTimeoutException("Regular expression backtracking stack overflow");
+    }
+}
diff --git a/Jint/Runtime/RegExp/RegExpMatchResult.cs b/Jint/Runtime/RegExp/RegExpMatchResult.cs
new file mode 100644
index 0000000000..6c3216ce4c
--- /dev/null
+++ b/Jint/Runtime/RegExp/RegExpMatchResult.cs
@@ -0,0 +1,28 @@
+using System.Runtime.InteropServices;
+
+namespace Jint.Runtime.RegExp;
+
+/// <summary>
+/// Result of a single regex match operation.
+/// </summary>
+[StructLayout(LayoutKind.Auto)]
+internal readonly record struct RegExpMatchResult(
+    bool Success,
+    int Index,
+    int Length,
+    string Value,
+    RegExpGroupResult[]? Groups)
+{
+    public static RegExpMatchResult NoMatch => new(false, 0, 0, "", null);
+}
+
+/// <summary>
+/// Result for a single capture group within a match.
+/// </summary>
+[StructLayout(LayoutKind.Auto)]
+internal readonly record struct RegExpGroupResult(
+    bool Success,
+    int Index,
+    int Length,
+    string Value,
+    string? Name);
diff --git a/Jint/Runtime/RegExp/RegExpOpcode.cs b/Jint/Runtime/RegExp/RegExpOpcode.cs
new file mode 100644
index 0000000000..ecffd92339
--- /dev/null
+++ b/Jint/Runtime/RegExp/RegExpOpcode.cs
@@ -0,0 +1,146 @@
+// Ported from QuickJS libregexp-opcode.h
+// Copyright (c) 2017-2018 Fabrice Bellard - MIT License
+
+namespace Jint.Runtime.RegExp;
+
+/// <summary>
+/// Regular expression bytecode opcodes. Each opcode has a fixed base size
+/// (some are variable-length due to trailing range data).
+/// </summary>
+internal enum RegExpOpcode : byte
+{
+    Invalid = 0,     // size: 1 - never used
+    Char,            // size: 3 - match 16-bit character
+    CharI,           // size: 3 - match 16-bit character, case-insensitive
+    Char32,          // size: 5 - match 32-bit code point
+    Char32I,         // size: 5 - match 32-bit code point, case-insensitive
+    Dot,             // size: 1 - match any char except line terminators
+    Any,             // size: 1 - match any char including line terminators
+    Space,           // size: 1 - match whitespace
+    NotSpace,        // size: 1 - match non-whitespace (must come after Space)
+    LineStart,       // size: 1 - ^
+    LineStartM,      // size: 1 - ^ with multiline flag
+    LineEnd,         // size: 1 - $
+    LineEndM,        // size: 1 - $ with multiline flag
+    Goto,            // size: 5 - unconditional jump (relative offset as int32)
+    SplitGotoFirst,  // size: 5 - NFA branch: try goto first, then next
+    SplitNextFirst,  // size: 5 - NFA branch: try next first, then goto
+    Match,           // size: 1 - successful match
+    LookaheadMatch,  // size: 1 - successful lookahead match
+    NegativeLookaheadMatch, // size: 1 - successful negative lookahead match (must come after)
+    SaveStart,       // size: 2 - save start position of capture group
+    SaveEnd,         // size: 2 - save end position of capture group (must come after SaveStart)
+    SaveReset,       // size: 3 - reset capture group positions
+    Loop,            // size: 6 - decrement top of stack and goto if != 0
+    LoopSplitGotoFirst,       // size: 10 - loop then split (greedy)
+    LoopSplitNextFirst,       // size: 10 - loop then split (lazy)
+    LoopCheckAdvSplitGotoFirst, // size: 10 - loop, check advance, then split (greedy)
+    LoopCheckAdvSplitNextFirst, // size: 10 - loop, check advance, then split (lazy)
+    SetI32,          // size: 6 - store immediate value to register
+    WordBoundary,    // size: 1 - \b
+    WordBoundaryI,   // size: 1 - \b case-insensitive
+    NotWordBoundary, // size: 1 - \B
+    NotWordBoundaryI,// size: 1 - \B case-insensitive
+    BackReference,   // size: 2 - \N backreference (variable length match)
+    BackReferenceI,  // size: 2 - \N case-insensitive (must come after)
+    BackwardBackReference,  // size: 2 - backward \N for lookbehind (must come after)
+    BackwardBackReferenceI, // size: 2 - backward \N case-insensitive (must come after)
+    Range,           // size: 3+ - character range (variable length, 16-bit pairs)
+    RangeI,          // size: 3+ - character range, case-insensitive
+    Range32,         // size: 3+ - character range (variable length, 32-bit pairs)
+    Range32I,        // size: 3+ - character range, case-insensitive
+    Lookahead,       // size: 5 - positive lookahead (?=...)
+    NegativeLookahead, // size: 5 - negative lookahead (?!...) (must come after)
+    SetCharPos,      // size: 2 - store character position to register
+    CheckAdvance,    // size: 2 - check register differs from current position
+    Prev,            // size: 1 - go to previous character (for lookbehind)
+
+    Count
+}
+
+/// <summary>
+/// Base sizes for each opcode (excluding variable-length range data).
+/// </summary>
+internal static class RegExpOpcodeInfo
+{
+    private static ReadOnlySpan<byte> Sizes =>
+    [
+        1,  // Invalid
+        3,  // Char
+        3,  // CharI
+        5,  // Char32
+        5,  // Char32I
+        1,  // Dot
+        1,  // Any
+        1,  // Space
+        1,  // NotSpace
+        1,  // LineStart
+        1,  // LineStartM
+        1,  // LineEnd
+        1,  // LineEndM
+        5,  // Goto
+        5,  // SplitGotoFirst
+        5,  // SplitNextFirst
+        1,  // Match
+        1,  // LookaheadMatch
+        1,  // NegativeLookaheadMatch
+        2,  // SaveStart
+        2,  // SaveEnd
+        3,  // SaveReset
+        6,  // Loop
+        10, // LoopSplitGotoFirst
+        10, // LoopSplitNextFirst
+        10, // LoopCheckAdvSplitGotoFirst
+        10, // LoopCheckAdvSplitNextFirst
+        6,  // SetI32
+        1,  // WordBoundary
+        1,  // WordBoundaryI
+        1,  // NotWordBoundary
+        1,  // NotWordBoundaryI
+        2,  // BackReference
+        2,  // BackReferenceI
+        2,  // BackwardBackReference
+        2,  // BackwardBackReferenceI
+        3,  // Range
+        3,  // RangeI
+        3,  // Range32
+        3,  // Range32I
+        5,  // Lookahead
+        5,  // NegativeLookahead
+        2,  // SetCharPos
+        2,  // CheckAdvance
+        1,  // Prev
+    ];
+
+    public static int GetSize(RegExpOpcode op) => Sizes[(int) op];
+}
+
+/// <summary>
+/// Regex flags stored in bytecode header.
+/// </summary>
+[Flags]
+internal enum RegExpFlags : ushort
+{
+    None = 0,
+    Global = 1 << 0,
+    IgnoreCase = 1 << 1,
+    Multiline = 1 << 2,
+    DotAll = 1 << 3,
+    Unicode = 1 << 4,
+    Sticky = 1 << 5,
+    Indices = 1 << 6,
+    NamedGroups = 1 << 7,
+    UnicodeSets = 1 << 8,
+}
+
+/// <summary>
+/// Bytecode header layout constants.
+/// </summary>
+internal static class RegExpHeader
+{
+    public const int OffsetFlags = 0;          // uint16
+    public const int OffsetCaptureCount = 2;   // byte
+    public const int OffsetRegisterCount = 3;  // byte
+    public const int OffsetBytecodeLen = 4;    // int32 (little-endian)
+    public const int Length = 8;
+}
diff --git a/Jint/Runtime/RegExp/RegExpSyntaxException.cs b/Jint/Runtime/RegExp/RegExpSyntaxException.cs
new file mode 100644
index 0000000000..f7389073cd
--- /dev/null
+++ b/Jint/Runtime/RegExp/RegExpSyntaxException.cs
@@ -0,0 +1,11 @@
+namespace Jint.Runtime.RegExp;
+
+/// <summary>
+/// Thrown when a regex pattern has a syntax error during custom engine compilation.
+/// </summary>
+internal sealed class RegExpSyntaxException : Exception
+{
+    public RegExpSyntaxException(string message) : base(message)
+    {
+    }
+}
diff --git a/Jint/Runtime/RegExp/Unicode/UnicodeData.cs b/Jint/Runtime/RegExp/Unicode/UnicodeData.cs
new file mode 100644
index 0000000000..857e093d84
--- /dev/null
+++ b/Jint/Runtime/RegExp/Unicode/UnicodeData.cs
@@ -0,0 +1,1636 @@
+// Unicode data tables for JavaScript regex engine
+// Auto-generated from QuickJS-NG libunicode-table.h
+// Original copyright (c) 2017-2018 Fabrice Bellard - MIT License
+
+namespace Jint.Runtime.RegExp.Unicode;
+
+/// <summary>
+/// Compressed Unicode tables: General Category, Script, Binary Properties, Case Conversion.
+/// Data from QuickJS-NG libunicode-table.h (Unicode 17.0).
+/// </summary>
+internal static partial class UnicodeData
+{
+    // ---- General Category constants ----
+    internal const int GcCn = 0, GcLu = 1, GcLl = 2, GcLt = 3, GcLm = 4, GcLo = 5;
+    internal const int GcMn = 6, GcMc = 7, GcMe = 8, GcNd = 9, GcNl = 10, GcNo = 11;
+    internal const int GcSm = 12, GcSc = 13, GcSk = 14, GcSo = 15;
+    internal const int GcPc = 16, GcPd = 17, GcPs = 18, GcPe = 19, GcPi = 20, GcPf = 21, GcPo = 22;
+    internal const int GcZs = 23, GcZl = 24, GcZp = 25;
+    internal const int GcCc = 26, GcCf = 27, GcCs = 28, GcCo = 29;
+    internal const int GcLC = 30, GcL = 31, GcM = 32, GcN = 33, GcS = 34, GcP = 35, GcZ = 36, GcC = 37;
+
+    internal static readonly uint[] GcMaskTable =
+    {
+        (1u<<GcLu)|(1u<<GcLl)|(1u<<GcLt),
+        (1u<<GcLu)|(1u<<GcLl)|(1u<<GcLt)|(1u<<GcLm)|(1u<<GcLo),
+        (1u<<GcMn)|(1u<<GcMc)|(1u<<GcMe),
+        (1u<<GcNd)|(1u<<GcNl)|(1u<<GcNo),
+        (1u<<GcSm)|(1u<<GcSc)|(1u<<GcSk)|(1u<<GcSo),
+        (1u<<GcPc)|(1u<<GcPd)|(1u<<GcPs)|(1u<<GcPe)|(1u<<GcPi)|(1u<<GcPf)|(1u<<GcPo),
+        (1u<<GcZs)|(1u<<GcZl)|(1u<<GcZp),
+        (1u<<GcCc)|(1u<<GcCf)|(1u<<GcCs)|(1u<<GcCo)|(1u<<GcCn),
+    };
+
+    internal const int ScriptUnknown = 0;
+    internal const int ScriptCommon = 26;
+    internal const int ScriptInherited = 59;
+
+    // Property index constants
+    internal const int PropHyphen = 0, PropOtherMath = 1, PropOtherAlphabetic = 2;
+    internal const int PropOtherLowercase = 3, PropOtherUppercase = 4;
+    internal const int PropOtherGraphemeExtend = 5, PropOtherDefaultIgnorableCodePoint = 6;
+    internal const int PropOtherIDStart = 7, PropOtherIDContinue = 8;
+    internal const int PropPrependedConcatenationMark = 9, PropIDContinue1 = 10;
+    internal const int PropXIDStart1 = 11, PropXIDContinue1 = 12;
+    internal const int PropChangesWhenTitlecased1 = 13, PropChangesWhenCasefolded1 = 14;
+    internal const int PropChangesWhenNFKCCasefolded1 = 15;
+    internal const int PropBasicEmoji1 = 16, PropBasicEmoji2 = 17;
+    internal const int PropRGIEmojiModifierSequence = 18, PropRGIEmojiFlagSequence = 19;
+    internal const int PropEmojiKeycapSequence = 20;
+    internal const int PropASCIIHexDigit = 21;
+    internal const int PropPatternSyntax = 36, PropPatternWhiteSpace = 37;
+    internal const int PropEmojiModifierBase = 51;
+    internal const int PropIDStart = 55, PropCaseIgnorable = 56;
+    internal const int PropASCII = 57, PropAlphabetic = 58, PropAny = 59, PropAssigned = 60;
+    internal const int PropCased = 61;
+    internal const int PropChangesWhenCasefolded = 62, PropChangesWhenCasemapped = 63;
+    internal const int PropChangesWhenLowercased = 64, PropChangesWhenNFKCCasefolded = 65;
+    internal const int PropChangesWhenTitlecased = 66, PropChangesWhenUppercased = 67;
+    internal const int PropGraphemeBase = 68, PropGraphemeExtend = 69;
+    internal const int PropIDContinue = 70;
+    internal const int PropLowercase = 74, PropMath = 75, PropUppercase = 76;
+    internal const int PropXIDContinue = 77, PropXIDStart = 78;
+    internal const int PropTableCount = 57;
+
+    internal const int SeqPropBasicEmoji = 0, SeqPropEmojiKeycapSequence = 1;
+    internal const int SeqPropRGIEmojiModifierSequence = 2, SeqPropRGIEmojiFlagSequence = 3;
+    internal const int SeqPropRGIEmojiTagSequence = 4, SeqPropRGIEmojiZWJSequence = 5;
+    internal const int SeqPropRGIEmoji = 6;
+
+    internal static readonly string GcNameTable = "Cn,Unassigned\\0Lu,Uppercase_Letter\\0Ll,Lowercase_Letter\\0Lt,Titlecase_Letter\\0Lm,Modifier_Letter\\0Lo,Other_Letter\\0Mn,Nonspacing_Mark\\0Mc,Spacing_Mark\\0Me,Enclosing_Mark\\0Nd,Decimal_Number,digit\\0Nl,Letter_Number\\0No,Other_Number\\0Sm,Math_Symbol\\0Sc,Currency_Symbol\\0Sk,Modifier_Symbol\\0So,Other_Symbol\\0Pc,Connector_Punctuation\\0Pd,Dash_Punctuation\\0Ps,Open_Punctuation\\0Pe,Close_Punctuation\\0Pi,Initial_Punctuation\\0Pf,Final_Punctuation\\0Po,Other_Punctuation\\0Zs,Space_Separator\\0Zl,Line_Separator\\0Zp,Paragraph_Separator\\0Cc,Control,cntrl\\0Cf,Format\\0Cs,Surrogate\\0Co,Private_Use\\0LC,Cased_Letter\\0L,Letter\\0M,Mark,Combining_Mark\\0N,Number\\0S,Symbol\\0P,Punctuation,punct\\0Z,Separator\\0C,Other\\0";
+
+    internal static readonly string ScriptNameTable = "Unknown,Zzzz\\0Adlam,Adlm\\0Ahom,Ahom\\0Anatolian_Hieroglyphs,Hluw\\0Arabic,Arab\\0Armenian,Armn\\0Avestan,Avst\\0Balinese,Bali\\0Bamum,Bamu\\0Bassa_Vah,Bass\\0Batak,Batk\\0Bengali,Beng\\0Beria_Erfe,Berf\\0Bhaiksuki,Bhks\\0Bopomofo,Bopo\\0Brahmi,Brah\\0Braille,Brai\\0Buginese,Bugi\\0Buhid,Buhd\\0Canadian_Aboriginal,Cans\\0Carian,Cari\\0Caucasian_Albanian,Aghb\\0Chakma,Cakm\\0Cham,Cham\\0Cherokee,Cher\\0Chorasmian,Chrs\\0Common,Zyyy\\0Coptic,Copt,Qaac\\0Cuneiform,Xsux\\0Cypriot,Cprt\\0Cyrillic,Cyrl\\0Cypro_Minoan,Cpmn\\0Deseret,Dsrt\\0Devanagari,Deva\\0Dives_Akuru,Diak\\0Dogra,Dogr\\0Duployan,Dupl\\0Egyptian_Hieroglyphs,Egyp\\0Elbasan,Elba\\0Elymaic,Elym\\0Ethiopic,Ethi\\0Georgian,Geor\\0Glagolitic,Glag\\0Gothic,Goth\\0Garay,Gara\\0Grantha,Gran\\0Greek,Grek\\0Gujarati,Gujr\\0Gunjala_Gondi,Gong\\0Gurmukhi,Guru\\0Gurung_Khema,Gukh\\0Han,Hani\\0Hangul,Hang\\0Hanifi_Rohingya,Rohg\\0Hanunoo,Hano\\0Hatran,Hatr\\0Hebrew,Hebr\\0Hiragana,Hira\\0Imperial_Aramaic,Armi\\0Inherited,Zinh,Qaai\\0Inscriptional_Pahlavi,Phli\\0Inscriptional_Parthian,Prti\\0Javanese,Java\\0Kaithi,Kthi\\0Kannada,Knda\\0Katakana,Kana\\0Katakana_Or_Hiragana,Hrkt\\0Kawi,Kawi\\0Kayah_Li,Kali\\0Kharoshthi,Khar\\0Khmer,Khmr\\0Khojki,Khoj\\0Khitan_Small_Script,Kits\\0Khudawadi,Sind\\0Kirat_Rai,Krai\\0Lao,Laoo\\0Latin,Latn\\0Lepcha,Lepc\\0Limbu,Limb\\0Linear_A,Lina\\0Linear_B,Linb\\0Lisu,Lisu\\0Lycian,Lyci\\0Lydian,Lydi\\0Makasar,Maka\\0Mahajani,Mahj\\0Malayalam,Mlym\\0Mandaic,Mand\\0Manichaean,Mani\\0Marchen,Marc\\0Masaram_Gondi,Gonm\\0Medefaidrin,Medf\\0Meetei_Mayek,Mtei\\0Mende_Kikakui,Mend\\0Meroitic_Cursive,Merc\\0Meroitic_Hieroglyphs,Mero\\0Miao,Plrd\\0Modi,Modi\\0Mongolian,Mong\\0Mro,Mroo\\0Multani,Mult\\0Myanmar,Mymr\\0Nabataean,Nbat\\0Nag_Mundari,Nagm\\0Nandinagari,Nand\\0New_Tai_Lue,Talu\\0Newa,Newa\\0Nko,Nkoo\\0Nushu,Nshu\\0Nyiakeng_Puachue_Hmong,Hmnp\\0Ogham,Ogam\\0Ol_Chiki,Olck\\0Ol_Onal,Onao\\0Old_Hungarian,Hung\\0Old_Italic,Ital\\0Old_North_Arabian,Narb\\0Old_Permic,Perm\\0Old_Persian,Xpeo\\0Old_Sogdian,Sogo\\0Old_South_Arabian,Sarb\\0Old_Turkic,Orkh\\0Old_Uyghur,Ougr\\0Oriya,Orya\\0Osage,Osge\\0Osmanya,Osma\\0Pahawh_Hmong,Hmng\\0Palmyrene,Palm\\0Pau_Cin_Hau,Pauc\\0Phags_Pa,Phag\\0Phoenician,Phnx\\0Psalter_Pahlavi,Phlp\\0Rejang,Rjng\\0Runic,Runr\\0Samaritan,Samr\\0Saurashtra,Saur\\0Sharada,Shrd\\0Shavian,Shaw\\0Siddham,Sidd\\0Sidetic,Sidt\\0SignWriting,Sgnw\\0Sinhala,Sinh\\0Sogdian,Sogd\\0Sora_Sompeng,Sora\\0Soyombo,Soyo\\0Sundanese,Sund\\0Sunuwar,Sunu\\0Syloti_Nagri,Sylo\\0Syriac,Syrc\\0Tagalog,Tglg\\0Tagbanwa,Tagb\\0Tai_Le,Tale\\0Tai_Tham,Lana\\0Tai_Viet,Tavt\\0Tai_Yo,Tayo\\0Takri,Takr\\0Tamil,Taml\\0Tangut,Tang\\0Telugu,Telu\\0Thaana,Thaa\\0Thai,Thai\\0Tibetan,Tibt\\0Tifinagh,Tfng\\0Tirhuta,Tirh\\0Tangsa,Tnsa\\0Todhri,Todr\\0Tolong_Siki,Tols\\0Toto,Toto\\0Tulu_Tigalari,Tutg\\0Ugaritic,Ugar\\0Vai,Vaii\\0Vithkuqi,Vith\\0Wancho,Wcho\\0Warang_Citi,Wara\\0Yezidi,Yezi\\0Yi,Yiii\\0Zanabazar_Square,Zanb\\0";
+
+    internal static readonly string PropNameTable = "ASCII_Hex_Digit,AHex\\0Bidi_Control,Bidi_C\\0Dash\\0Deprecated,Dep\\0Diacritic,Dia\\0Extender,Ext\\0Hex_Digit,Hex\\0IDS_Unary_Operator,IDSU\\0IDS_Binary_Operator,IDSB\\0IDS_Trinary_Operator,IDST\\0Ideographic,Ideo\\0Join_Control,Join_C\\0Logical_Order_Exception,LOE\\0Modifier_Combining_Mark,MCM\\0Noncharacter_Code_Point,NChar\\0Pattern_Syntax,Pat_Syn\\0Pattern_White_Space,Pat_WS\\0Quotation_Mark,QMark\\0Radical\\0Regional_Indicator,RI\\0Sentence_Terminal,STerm\\0Soft_Dotted,SD\\0Terminal_Punctuation,Term\\0Unified_Ideograph,UIdeo\\0Variation_Selector,VS\\0White_Space,space\\0Bidi_Mirrored,Bidi_M\\0Emoji\\0Emoji_Component,EComp\\0Emoji_Modifier,EMod\\0Emoji_Modifier_Base,EBase\\0Emoji_Presentation,EPres\\0Extended_Pictographic,ExtPict\\0Default_Ignorable_Code_Point,DI\\0ID_Start,IDS\\0Case_Ignorable,CI\\0ASCII\\0Alphabetic,Alpha\\0Any\\0Assigned\\0Cased\\0Changes_When_Casefolded,CWCF\\0Changes_When_Casemapped,CWCM\\0Changes_When_Lowercased,CWL\\0Changes_When_NFKC_Casefolded,CWKCF\\0Changes_When_Titlecased,CWT\\0Changes_When_Uppercased,CWU\\0Grapheme_Base,Gr_Base\\0Grapheme_Extend,Gr_Ext\\0ID_Continue,IDC\\0ID_Compat_Math_Start\\0ID_Compat_Math_Continue\\0InCB\\0Lowercase,Lower\\0Math\\0Uppercase,Upper\\0XID_Continue,XIDC\\0XID_Start,XIDS\\0";
+
+    internal static readonly string SequencePropNameTable = "Basic_Emoji\\0Emoji_Keycap_Sequence\\0RGI_Emoji_Modifier_Sequence\\0RGI_Emoji_Flag_Sequence\\0RGI_Emoji_Tag_Sequence\\0RGI_Emoji_ZWJ_Sequence\\0RGI_Emoji\\0";
+
+    // ---- Case conversion tables ----
+    // PERF: ReadOnlySpan<byte> properties (=> new byte[] { ... }) are embedded directly
+    // in the PE .text section by the C# compiler — zero heap allocation at runtime.
+    // This optimization ONLY works for byte/sbyte/bool element types.
+    // For uint/ushort, use static readonly fields instead (one-time heap alloc at class init).
+    internal static readonly uint[] CaseConvTable1 =
+    {
+        0x00209a30, 0x00309a00, 0x005a8173, 0x00601730, 0x006c0730, 0x006f81b3, 0x00701700, 0x007c0700,
+        0x007f8100, 0x00803040, 0x009801c3, 0x00988190, 0x00990640, 0x009c9040, 0x00a481b4, 0x00a52e40,
+        0x00bc0130, 0x00bc8640, 0x00bf8170, 0x00c00100, 0x00c08130, 0x00c10440, 0x00c30130, 0x00c38240,
+        0x00c48230, 0x00c58240, 0x00c70130, 0x00c78130, 0x00c80130, 0x00c88240, 0x00c98130, 0x00ca0130,
+        0x00ca8100, 0x00cb0130, 0x00cb8130, 0x00cc0240, 0x00cd0100, 0x00cd8101, 0x00ce0130, 0x00ce8130,
+        0x00cf0100, 0x00cf8130, 0x00d00640, 0x00d30130, 0x00d38240, 0x00d48130, 0x00d60240, 0x00d70130,
+        0x00d78240, 0x00d88230, 0x00d98440, 0x00db8130, 0x00dc0240, 0x00de0240, 0x00df8100, 0x00e20350,
+        0x00e38350, 0x00e50350, 0x00e69040, 0x00ee8100, 0x00ef1240, 0x00f801b4, 0x00f88350, 0x00fa0240,
+        0x00fb0130, 0x00fb8130, 0x00fc2840, 0x01100130, 0x01111240, 0x011d0131, 0x011d8240, 0x011e8130,
+        0x011f0131, 0x011f8201, 0x01208240, 0x01218130, 0x01220130, 0x01228130, 0x01230a40, 0x01280101,
+        0x01288101, 0x01290101, 0x01298100, 0x012a0100, 0x012b0200, 0x012c8100, 0x012d8100, 0x012e0101,
+        0x01300100, 0x01308101, 0x01318100, 0x01320101, 0x01328101, 0x01330101, 0x01340100, 0x01348100,
+        0x01350101, 0x01358101, 0x01360101, 0x01378100, 0x01388101, 0x01390100, 0x013a8100, 0x013e8101,
+        0x01400100, 0x01410101, 0x01418100, 0x01438101, 0x01440100, 0x01448100, 0x01450200, 0x01460100,
+        0x01490100, 0x014e8101, 0x014f0101, 0x01a28173, 0x01b80440, 0x01bb0240, 0x01bd8300, 0x01bf8130,
+        0x01c30130, 0x01c40330, 0x01c60130, 0x01c70230, 0x01c801d0, 0x01c89130, 0x01d18930, 0x01d60100,
+        0x01d68300, 0x01d801d3, 0x01d89100, 0x01e10173, 0x01e18900, 0x01e60100, 0x01e68200, 0x01e78130,
+        0x01e80173, 0x01e88173, 0x01ea8173, 0x01eb0173, 0x01eb8100, 0x01ec1840, 0x01f80173, 0x01f88173,
+        0x01f90100, 0x01f98100, 0x01fa01a0, 0x01fa8173, 0x01fb8240, 0x01fc8130, 0x01fd0240, 0x01fe8330,
+        0x02001030, 0x02082030, 0x02182000, 0x02281000, 0x02302240, 0x02453640, 0x02600130, 0x02608e40,
+        0x02678100, 0x02686040, 0x0298a630, 0x02b0a600, 0x02c381b5, 0x08502631, 0x08638131, 0x08668131,
+        0x08682b00, 0x087e8300, 0x09d05011, 0x09f80610, 0x09fc0620, 0x0e400174, 0x0e408174, 0x0e410174,
+        0x0e418174, 0x0e420174, 0x0e428174, 0x0e430174, 0x0e438180, 0x0e440180, 0x0e448240, 0x0e482b30,
+        0x0e5e8330, 0x0ebc8101, 0x0ebe8101, 0x0ec70101, 0x0f007e40, 0x0f3f1840, 0x0f4b01b5, 0x0f4b81b6,
+        0x0f4c01b6, 0x0f4c81b6, 0x0f4d01b7, 0x0f4d8180, 0x0f4f0130, 0x0f506040, 0x0f800800, 0x0f840830,
+        0x0f880600, 0x0f8c0630, 0x0f900800, 0x0f940830, 0x0f980800, 0x0f9c0830, 0x0fa00600, 0x0fa40630,
+        0x0fa801b0, 0x0fa88100, 0x0fa901d3, 0x0fa98100, 0x0faa01d3, 0x0faa8100, 0x0fab01d3, 0x0fab8100,
+        0x0fac8130, 0x0fad8130, 0x0fae8130, 0x0faf8130, 0x0fb00800, 0x0fb40830, 0x0fb80200, 0x0fb90400,
+        0x0fbb0201, 0x0fbc0201, 0x0fbd0201, 0x0fbe0201, 0x0fc008b7, 0x0fc40867, 0x0fc808b8, 0x0fcc0868,
+        0x0fd008b8, 0x0fd40868, 0x0fd80200, 0x0fd901b9, 0x0fd981b1, 0x0fda01b9, 0x0fdb01b1, 0x0fdb81d7,
+        0x0fdc0230, 0x0fdd0230, 0x0fde0161, 0x0fdf0173, 0x0fe101b9, 0x0fe181b2, 0x0fe201ba, 0x0fe301b2,
+        0x0fe381d8, 0x0fe40430, 0x0fe60162, 0x0fe80201, 0x0fe901d0, 0x0fe981d0, 0x0feb01b0, 0x0feb81d0,
+        0x0fec0230, 0x0fed0230, 0x0ff00201, 0x0ff101d3, 0x0ff181d3, 0x0ff201ba, 0x0ff28101, 0x0ff301b0,
+        0x0ff381d3, 0x0ff40231, 0x0ff50230, 0x0ff60131, 0x0ff901ba, 0x0ff981b2, 0x0ffa01bb, 0x0ffb01b2,
+        0x0ffb81d9, 0x0ffc0230, 0x0ffd0230, 0x0ffe0162, 0x109301a0, 0x109501a0, 0x109581a0, 0x10990131,
+        0x10a70101, 0x10b01031, 0x10b81001, 0x10c18240, 0x125b1a31, 0x12681a01, 0x16003031, 0x16183001,
+        0x16300240, 0x16310130, 0x16318130, 0x16320130, 0x16328100, 0x16330100, 0x16338640, 0x16368130,
+        0x16370130, 0x16378130, 0x16380130, 0x16390240, 0x163a8240, 0x163f0230, 0x16406440, 0x16758440,
+        0x16790240, 0x16802600, 0x16938100, 0x16968100, 0x53202e40, 0x53401c40, 0x53910e40, 0x53993e40,
+        0x53bc8440, 0x53be8130, 0x53bf0a40, 0x53c58240, 0x53c68130, 0x53c80440, 0x53ca0101, 0x53cb1440,
+        0x53d50130, 0x53d58130, 0x53d60130, 0x53d68130, 0x53d70130, 0x53d80130, 0x53d88130, 0x53d90130,
+        0x53d98131, 0x53da1040, 0x53e20131, 0x53e28130, 0x53e30130, 0x53e38440, 0x53e58130, 0x53e61040,
+        0x53ee0130, 0x53fa8240, 0x55a98101, 0x55b85020, 0x7d8001b2, 0x7d8081b2, 0x7d8101b2, 0x7d8181da,
+        0x7d8201da, 0x7d8281b3, 0x7d8301b3, 0x7d8981bb, 0x7d8a01bb, 0x7d8a81bb, 0x7d8b01bc, 0x7d8b81bb,
+        0x7f909a31, 0x7fa09a01, 0x82002831, 0x82142801, 0x82582431, 0x826c2401, 0x82b80b31, 0x82be0f31,
+        0x82c60731, 0x82ca0231, 0x82cb8b01, 0x82d18f01, 0x82d98701, 0x82dd8201, 0x86403331, 0x86603301,
+        0x86a81631, 0x86b81601, 0x8c502031, 0x8c602001, 0xb7202031, 0xb7302001, 0xb7501931, 0xb75d9901,
+        0xf4802231, 0xf4912201,
+    };
+    internal static ReadOnlySpan<byte> CaseConvTable2 => new byte[]
+    {
+        0x01, 0x00, 0x9c, 0x06, 0x07, 0x4d, 0x03, 0x04, 0x10, 0x00, 0x8f, 0x0b, 0x00, 0x00, 0x11, 0x00,
+        0x08, 0x00, 0x53, 0x4b, 0x52, 0x00, 0x53, 0x00, 0x54, 0x00, 0x3b, 0x55, 0x56, 0x00, 0x58, 0x5a,
+        0x40, 0x5f, 0x5e, 0x00, 0x47, 0x50, 0x63, 0x65, 0x43, 0x66, 0x00, 0x68, 0x00, 0x6a, 0x00, 0x6c,
+        0x00, 0x6e, 0x00, 0x70, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x93, 0x00, 0x00,
+        0x20, 0x36, 0x00, 0x28, 0x00, 0x24, 0x00, 0x24, 0x25, 0x2d, 0x00, 0x13, 0x6d, 0x6f, 0x00, 0x29,
+        0x27, 0x2a, 0x14, 0x16, 0x18, 0x1b, 0x1c, 0x41, 0x1e, 0x42, 0x1f, 0x4e, 0x3c, 0x40, 0x22, 0x21,
+        0x44, 0x21, 0x43, 0x26, 0x28, 0x27, 0x29, 0x23, 0x2b, 0x4b, 0x2d, 0x46, 0x2f, 0x4c, 0x31, 0x4d,
+        0x33, 0x47, 0x45, 0x99, 0x00, 0x00, 0x97, 0x91, 0x7f, 0x80, 0x85, 0x86, 0x12, 0x82, 0x84, 0x78,
+        0x79, 0x12, 0x7d, 0xa3, 0x7e, 0x7a, 0x7b, 0x8c, 0x92, 0x98, 0xa6, 0xa0, 0x87, 0x00, 0x9a, 0xa1,
+        0x95, 0x77, 0x33, 0x95, 0x00, 0x90, 0x00, 0x76, 0x9b, 0x9a, 0x99, 0x98, 0x00, 0x00, 0xa0, 0x00,
+        0x9e, 0x00, 0xa3, 0xa2, 0x15, 0x31, 0x32, 0x33, 0xb7, 0xb8, 0x53, 0xac, 0xab, 0x12, 0x14, 0x1e,
+        0x21, 0x22, 0x22, 0x2a, 0x34, 0x35, 0x00, 0xa8, 0xa9, 0x39, 0x22, 0x4c, 0x00, 0x00, 0x97, 0x01,
+        0x5a, 0xda, 0x1d, 0x36, 0x05, 0x00, 0xc7, 0xc6, 0xc9, 0xc8, 0xcb, 0xca, 0xcd, 0xcc, 0xcf, 0xce,
+        0xc4, 0xd8, 0x45, 0xd9, 0x42, 0xda, 0x46, 0xdb, 0xd1, 0xd3, 0xd5, 0xd7, 0xdd, 0xdc, 0xf1, 0xf9,
+        0x01, 0x11, 0x0a, 0x12, 0x80, 0x9f, 0x00, 0x21, 0x80, 0xa3, 0xf0, 0x00, 0xc0, 0x40, 0xc6, 0x60,
+        0xea, 0xde, 0xe6, 0x99, 0xc0, 0x00, 0x00, 0x06, 0x60, 0xdf, 0x29, 0x00, 0x15, 0x12, 0x06, 0x16,
+        0xfb, 0xe0, 0x09, 0x15, 0x12, 0x84, 0x0b, 0xc6, 0x16, 0x02, 0xe2, 0x06, 0xc0, 0x40, 0x00, 0x46,
+        0x60, 0xe1, 0xe3, 0x6d, 0x37, 0x38, 0x39, 0x18, 0x17, 0x1a, 0x19, 0x00, 0x1d, 0x1c, 0x1f, 0x1e,
+        0x00, 0x61, 0xba, 0x67, 0x45, 0x48, 0x00, 0x50, 0x64, 0x4f, 0x51, 0x00, 0x00, 0x49, 0x00, 0x00,
+        0x00, 0xa5, 0xa6, 0xa7, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb9, 0x00, 0x00, 0x5c, 0x00, 0x4a, 0x00,
+        0x5d, 0x57, 0x59, 0x62, 0x60, 0x72, 0x6b, 0x71, 0x52, 0x00, 0x3e, 0x69, 0xbb, 0x00, 0x5b, 0x00,
+        0x25, 0x00, 0x48, 0xaa, 0x8a, 0x8b, 0x8c, 0xab, 0xac, 0x58, 0x58, 0xaf, 0x94, 0xb0, 0x6f, 0xb2,
+        0x61, 0x60, 0x63, 0x62, 0x65, 0x64, 0x6a, 0x6b, 0x6c, 0x6d, 0x66, 0x67, 0x68, 0x69, 0x6f, 0x6e,
+        0x71, 0x70, 0x73, 0x72, 0x75, 0x74, 0x77, 0x76, 0x79, 0x78,
+    };
+    internal static readonly ushort[] CaseConvExt =
+    {
+        0x0399, 0x0308, 0x0301, 0x03a5, 0x0313, 0x0300, 0x0342, 0x0391,
+        0x0397, 0x03a9, 0x0046, 0x0049, 0x004c, 0x0053, 0x0069, 0x0307,
+        0x02bc, 0x004e, 0x004a, 0x030c, 0x0535, 0x0552, 0x0048, 0x0331,
+        0x0054, 0x0057, 0x030a, 0x0059, 0x0041, 0x02be, 0x1f08, 0x1f80,
+        0x1f28, 0x1f90, 0x1f68, 0x1fa0, 0x1fba, 0x0386, 0x1fb3, 0x1fca,
+        0x0389, 0x1fc3, 0x03a1, 0x1ffa, 0x038f, 0x1ff3, 0x0544, 0x0546,
+        0x053b, 0x054e, 0x053d, 0x03b8, 0x0462, 0xa64a, 0x1e60, 0x03c9,
+        0x006b, 0x00e5,
+    };
+
+    // ---- General Category table ----
+    internal static ReadOnlySpan<byte> GcTable => new byte[]
+    {
+        0xfa, 0x18, 0x17, 0x56, 0x0d, 0x56, 0x12, 0x13, 0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02, 0x36,
+        0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e, 0x10, 0x0e, 0xe2, 0x12, 0x12, 0x0c, 0x13, 0x0c,
+        0xfa, 0x19, 0x17, 0x16, 0x6d, 0x0f, 0x16, 0x0e, 0x0f, 0x05, 0x14, 0x0c, 0x1b, 0x0f, 0x0e, 0x0f,
+        0x0c, 0x2b, 0x0e, 0x02, 0x36, 0x0e, 0x0b, 0x05, 0x15, 0x4b, 0x16, 0xe1, 0x0f, 0x0c, 0xc1, 0xe2,
+        0x10, 0x0c, 0xe2, 0x00, 0xff, 0x30, 0x02, 0xff, 0x08, 0x02, 0xff, 0x27, 0xbf, 0x22, 0x21, 0x02,
+        0x5f, 0x5f, 0x21, 0x22, 0x61, 0x02, 0x21, 0x02, 0x41, 0x42, 0x21, 0x02, 0x21, 0x02, 0x9f, 0x7f,
+        0x02, 0x5f, 0x5f, 0x21, 0x02, 0x5f, 0x3f, 0x02, 0x05, 0x3f, 0x22, 0x65, 0x01, 0x03, 0x02, 0x01,
+        0x03, 0x02, 0x01, 0x03, 0x02, 0xff, 0x08, 0x02, 0xff, 0x0a, 0x02, 0x01, 0x03, 0x02, 0x5f, 0x21,
+        0x02, 0xff, 0x32, 0xa2, 0x21, 0x02, 0x21, 0x22, 0x5f, 0x41, 0x02, 0xff, 0x00, 0xe2, 0x3c, 0x25,
+        0xe2, 0x12, 0xe4, 0x0a, 0x6e, 0xe4, 0x04, 0xee, 0x06, 0x84, 0xce, 0x04, 0x0e, 0x04, 0xee, 0x09,
+        0xe6, 0x68, 0x7f, 0x04, 0x0e, 0x3f, 0x20, 0x04, 0x42, 0x16, 0x01, 0x60, 0x2e, 0x01, 0x16, 0x41,
+        0x00, 0x01, 0x00, 0x21, 0x02, 0xe1, 0x09, 0x00, 0xe1, 0x01, 0xe2, 0x1b, 0x3f, 0x02, 0x41, 0x42,
+        0xff, 0x10, 0x62, 0x3f, 0x0c, 0x5f, 0x3f, 0x02, 0xe1, 0x2b, 0xe2, 0x28, 0xff, 0x1a, 0x0f, 0x86,
+        0x28, 0xff, 0x2f, 0xff, 0x06, 0x02, 0xff, 0x58, 0x00, 0xe1, 0x1e, 0x20, 0x04, 0xb6, 0xe2, 0x21,
+        0x16, 0x11, 0x20, 0x2f, 0x0d, 0x00, 0xe6, 0x25, 0x11, 0x06, 0x16, 0x26, 0x16, 0x26, 0x16, 0x06,
+        0xe0, 0x00, 0xe5, 0x13, 0x60, 0x65, 0x36, 0xe0, 0x03, 0xbb, 0x4c, 0x36, 0x0d, 0x36, 0x2f, 0xe6,
+        0x03, 0x16, 0x1b, 0x56, 0xe5, 0x18, 0x04, 0xe5, 0x02, 0xe6, 0x0d, 0xe9, 0x02, 0x76, 0x25, 0x06,
+        0xe5, 0x5b, 0x16, 0x05, 0xc6, 0x1b, 0x0f, 0xa6, 0x24, 0x26, 0x0f, 0x66, 0x25, 0xe9, 0x02, 0x45,
+        0x2f, 0x05, 0xf6, 0x06, 0x00, 0x1b, 0x05, 0x06, 0xe5, 0x16, 0xe6, 0x13, 0x20, 0xe5, 0x51, 0xe6,
+        0x03, 0x05, 0xe0, 0x06, 0xe9, 0x02, 0xe5, 0x19, 0xe6, 0x01, 0x24, 0x0f, 0x56, 0x04, 0x20, 0x06,
+        0x2d, 0xe5, 0x0e, 0x66, 0x04, 0xe6, 0x01, 0x04, 0x46, 0x04, 0x86, 0x20, 0xf6, 0x07, 0x00, 0xe5,
+        0x11, 0x46, 0x20, 0x16, 0x00, 0xe5, 0x03, 0x80, 0xe5, 0x10, 0x0e, 0xc5, 0x3b, 0x80, 0xe6, 0x01,
+        0xe5, 0x21, 0x04, 0xe6, 0x10, 0x1b, 0xe6, 0x18, 0x07, 0xe5, 0x2e, 0x06, 0x07, 0x06, 0x05, 0x47,
+        0xe6, 0x00, 0x67, 0x06, 0x27, 0x05, 0xc6, 0xe5, 0x02, 0x26, 0x36, 0xe9, 0x02, 0x16, 0x04, 0xe5,
+        0x07, 0x06, 0x27, 0x00, 0xe5, 0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x05, 0x40,
+        0x65, 0x20, 0x06, 0x05, 0x47, 0x66, 0x20, 0x27, 0x20, 0x27, 0x06, 0x05, 0xe0, 0x00, 0x07, 0x60,
+        0x25, 0x00, 0x45, 0x26, 0x20, 0xe9, 0x02, 0x25, 0x2d, 0xab, 0x0f, 0x0d, 0x05, 0x16, 0x06, 0x20,
+        0x26, 0x07, 0x00, 0xa5, 0x60, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00, 0x25, 0x00,
+        0x25, 0x20, 0x06, 0x00, 0x47, 0x26, 0x60, 0x26, 0x20, 0x46, 0x40, 0x06, 0xc0, 0x65, 0x00, 0x05,
+        0xc0, 0xe9, 0x02, 0x26, 0x45, 0x06, 0x16, 0xe0, 0x02, 0x26, 0x07, 0x00, 0xe5, 0x01, 0x00, 0x45,
+        0x00, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00, 0x85, 0x20, 0x06, 0x05, 0x47, 0x86, 0x00, 0x26,
+        0x07, 0x00, 0x27, 0x06, 0x20, 0x05, 0xe0, 0x07, 0x25, 0x26, 0x20, 0xe9, 0x02, 0x16, 0x0d, 0xc0,
+        0x05, 0xa6, 0x00, 0x06, 0x27, 0x00, 0xe5, 0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00,
+        0x25, 0x00, 0x85, 0x20, 0x06, 0x05, 0x07, 0x06, 0x07, 0x66, 0x20, 0x27, 0x20, 0x27, 0x06, 0xc0,
+        0x26, 0x07, 0x60, 0x25, 0x00, 0x45, 0x26, 0x20, 0xe9, 0x02, 0x0f, 0x05, 0xab, 0xe0, 0x02, 0x06,
+        0x05, 0x00, 0xa5, 0x40, 0x45, 0x00, 0x65, 0x40, 0x25, 0x00, 0x05, 0x00, 0x25, 0x40, 0x25, 0x40,
+        0x45, 0x40, 0xe5, 0x04, 0x60, 0x27, 0x06, 0x27, 0x40, 0x47, 0x00, 0x47, 0x06, 0x20, 0x05, 0xa0,
+        0x07, 0xe0, 0x06, 0xe9, 0x02, 0x4b, 0xaf, 0x0d, 0x0f, 0x80, 0x06, 0x47, 0x06, 0xe5, 0x00, 0x00,
+        0x45, 0x00, 0xe5, 0x0f, 0x00, 0xe5, 0x08, 0x20, 0x06, 0x05, 0x46, 0x67, 0x00, 0x46, 0x00, 0x66,
+        0xc0, 0x26, 0x00, 0x45, 0x00, 0x25, 0x20, 0x25, 0x26, 0x20, 0xe9, 0x02, 0xc0, 0x16, 0xcb, 0x0f,
+        0x05, 0x06, 0x27, 0x16, 0xe5, 0x00, 0x00, 0x45, 0x00, 0xe5, 0x0f, 0x00, 0xe5, 0x02, 0x00, 0x85,
+        0x20, 0x06, 0x05, 0x07, 0x06, 0x87, 0x00, 0x06, 0x27, 0x00, 0x27, 0x26, 0xc0, 0x27, 0x80, 0x45,
+        0x00, 0x25, 0x26, 0x20, 0xe9, 0x02, 0x00, 0x25, 0x07, 0xe0, 0x04, 0x26, 0x27, 0xe5, 0x01, 0x00,
+        0x45, 0x00, 0xe5, 0x21, 0x26, 0x05, 0x47, 0x66, 0x00, 0x47, 0x00, 0x47, 0x06, 0x05, 0x0f, 0x60,
+        0x45, 0x07, 0xcb, 0x45, 0x26, 0x20, 0xe9, 0x02, 0xeb, 0x01, 0x0f, 0xa5, 0x00, 0x06, 0x27, 0x00,
+        0xe5, 0x0a, 0x40, 0xe5, 0x10, 0x00, 0xe5, 0x01, 0x00, 0x05, 0x20, 0xc5, 0x40, 0x06, 0x60, 0x47,
+        0x46, 0x00, 0x06, 0x00, 0xe7, 0x00, 0xa0, 0xe9, 0x02, 0x20, 0x27, 0x16, 0xe0, 0x04, 0xe5, 0x28,
+        0x06, 0x25, 0xc6, 0x60, 0x0d, 0xa5, 0x04, 0xe6, 0x00, 0x16, 0xe9, 0x02, 0x36, 0xe0, 0x1d, 0x25,
+        0x00, 0x05, 0x00, 0x85, 0x00, 0xe5, 0x10, 0x00, 0x05, 0x00, 0xe5, 0x02, 0x06, 0x25, 0xe6, 0x01,
+        0x05, 0x20, 0x85, 0x00, 0x04, 0x00, 0xc6, 0x00, 0xe9, 0x02, 0x20, 0x65, 0xe0, 0x18, 0x05, 0x4f,
+        0xf6, 0x07, 0x0f, 0x16, 0x4f, 0x26, 0xaf, 0xe9, 0x02, 0xeb, 0x02, 0x0f, 0x06, 0x0f, 0x06, 0x0f,
+        0x06, 0x12, 0x13, 0x12, 0x13, 0x27, 0xe5, 0x00, 0x00, 0xe5, 0x1c, 0x60, 0xe6, 0x06, 0x07, 0x86,
+        0x16, 0x26, 0x85, 0xe6, 0x03, 0x00, 0xe6, 0x1c, 0x00, 0xef, 0x00, 0x06, 0xaf, 0x00, 0x2f, 0x96,
+        0x6f, 0x36, 0xe0, 0x1d, 0xe5, 0x23, 0x27, 0x66, 0x07, 0xa6, 0x07, 0x26, 0x27, 0x26, 0x05, 0xe9,
+        0x02, 0xb6, 0xa5, 0x27, 0x26, 0x65, 0x46, 0x05, 0x47, 0x25, 0xc7, 0x45, 0x66, 0xe5, 0x05, 0x06,
+        0x27, 0x26, 0xa7, 0x06, 0x05, 0x07, 0xe9, 0x02, 0x47, 0x06, 0x2f, 0xe1, 0x1e, 0x00, 0x01, 0x80,
+        0x01, 0x20, 0xe2, 0x23, 0x16, 0x04, 0x42, 0xe5, 0x80, 0xc1, 0x00, 0x65, 0x20, 0xc5, 0x00, 0x05,
+        0x00, 0x65, 0x20, 0xe5, 0x21, 0x00, 0x65, 0x20, 0xe5, 0x19, 0x00, 0x65, 0x20, 0xc5, 0x00, 0x05,
+        0x00, 0x65, 0x20, 0xe5, 0x07, 0x00, 0xe5, 0x31, 0x00, 0x65, 0x20, 0xe5, 0x3b, 0x20, 0x46, 0xf6,
+        0x01, 0xeb, 0x0c, 0x40, 0xe5, 0x08, 0xef, 0x02, 0xa0, 0xe1, 0x4e, 0x20, 0xa2, 0x20, 0x11, 0xe5,
+        0x81, 0xe4, 0x0f, 0x16, 0xe5, 0x09, 0x17, 0xe5, 0x12, 0x12, 0x13, 0x40, 0xe5, 0x43, 0x56, 0x4a,
+        0xe5, 0x00, 0xc0, 0xe5, 0x0a, 0x46, 0x07, 0xe0, 0x01, 0xe5, 0x0b, 0x26, 0x07, 0x36, 0xe0, 0x01,
+        0xe5, 0x0a, 0x26, 0xe0, 0x04, 0xe5, 0x05, 0x00, 0x45, 0x00, 0x26, 0xe0, 0x04, 0xe5, 0x2c, 0x26,
+        0x07, 0xc6, 0xe7, 0x00, 0x06, 0x27, 0xe6, 0x03, 0x56, 0x04, 0x56, 0x0d, 0x05, 0x06, 0x20, 0xe9,
+        0x02, 0xa0, 0xeb, 0x02, 0xa0, 0xb6, 0x11, 0x76, 0x46, 0x1b, 0x06, 0xe9, 0x02, 0xa0, 0xe5, 0x1b,
+        0x04, 0xe5, 0x2d, 0xc0, 0x85, 0x26, 0xe5, 0x1a, 0x06, 0x05, 0x80, 0xe5, 0x3e, 0xe0, 0x02, 0xe5,
+        0x17, 0x00, 0x46, 0x67, 0x26, 0x47, 0x60, 0x27, 0x06, 0xa7, 0x46, 0x60, 0x0f, 0x40, 0x36, 0xe9,
+        0x02, 0xe5, 0x16, 0x20, 0x85, 0xe0, 0x03, 0xe5, 0x24, 0x60, 0xe5, 0x12, 0xa0, 0xe9, 0x02, 0x0b,
+        0x40, 0xef, 0x1a, 0xe5, 0x0f, 0x26, 0x27, 0x06, 0x20, 0x36, 0xe5, 0x2d, 0x07, 0x06, 0x07, 0xc6,
+        0x00, 0x06, 0x07, 0x06, 0x27, 0xe6, 0x00, 0xa7, 0xe6, 0x02, 0x20, 0x06, 0xe9, 0x02, 0xa0, 0xe9,
+        0x02, 0xa0, 0xd6, 0x04, 0xb6, 0x20, 0xe6, 0x06, 0x08, 0xe6, 0x17, 0x20, 0xe6, 0x04, 0xe0, 0x0c,
+        0x66, 0x07, 0xe5, 0x27, 0x06, 0x07, 0x86, 0x07, 0x06, 0x87, 0x06, 0x27, 0xe5, 0x00, 0x00, 0x36,
+        0xe9, 0x02, 0xd6, 0xef, 0x02, 0xe6, 0x01, 0xef, 0x01, 0x56, 0x26, 0x07, 0xe5, 0x16, 0x07, 0x66,
+        0x27, 0x26, 0x07, 0x46, 0x25, 0xe9, 0x02, 0xe5, 0x24, 0x06, 0x07, 0x26, 0x47, 0x06, 0x07, 0x46,
+        0x27, 0xe0, 0x00, 0x76, 0xe5, 0x1c, 0xe7, 0x00, 0xe6, 0x00, 0x27, 0x26, 0x40, 0x96, 0xe9, 0x02,
+        0x40, 0x45, 0xe9, 0x02, 0xe5, 0x16, 0xa4, 0x36, 0xe2, 0x01, 0x3f, 0x80, 0xe1, 0x23, 0x20, 0x41,
+        0xf6, 0x00, 0xe0, 0x00, 0x46, 0x16, 0xe6, 0x05, 0x07, 0xc6, 0x65, 0x06, 0xa5, 0x06, 0x25, 0x07,
+        0x26, 0x05, 0x80, 0xe2, 0x24, 0xe4, 0x37, 0xe2, 0x05, 0x04, 0xe2, 0x1a, 0xe4, 0x1d, 0xe6, 0x38,
+        0xff, 0x80, 0x0e, 0xe2, 0x00, 0xff, 0x5a, 0xe2, 0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20, 0xe2,
+        0x00, 0xe1, 0x00, 0xe2, 0x00, 0xe1, 0x00, 0xa2, 0x20, 0xa1, 0x20, 0xe2, 0x00, 0x00, 0x01, 0x00,
+        0x01, 0x00, 0x01, 0x00, 0x3f, 0xc2, 0xe1, 0x00, 0xe2, 0x06, 0x20, 0xe2, 0x00, 0xe3, 0x00, 0xe2,
+        0x00, 0xe3, 0x00, 0xe2, 0x00, 0xe3, 0x00, 0x82, 0x00, 0x22, 0x61, 0x03, 0x0e, 0x02, 0x4e, 0x42,
+        0x00, 0x22, 0x61, 0x03, 0x4e, 0x62, 0x20, 0x22, 0x61, 0x00, 0x4e, 0xe2, 0x00, 0x81, 0x4e, 0x20,
+        0x42, 0x00, 0x22, 0x61, 0x03, 0x2e, 0x00, 0xf7, 0x03, 0x9b, 0xb1, 0x36, 0x14, 0x15, 0x12, 0x34,
+        0x15, 0x12, 0x14, 0xf6, 0x00, 0x18, 0x19, 0x9b, 0x17, 0xf6, 0x01, 0x14, 0x15, 0x76, 0x30, 0x56,
+        0x0c, 0x12, 0x13, 0xf6, 0x03, 0x0c, 0x16, 0x10, 0xf6, 0x02, 0x17, 0x9b, 0x00, 0xfb, 0x02, 0x0b,
+        0x04, 0x20, 0xab, 0x4c, 0x12, 0x13, 0x04, 0xeb, 0x02, 0x4c, 0x12, 0x13, 0x00, 0xe4, 0x05, 0x40,
+        0xed, 0x1a, 0xe0, 0x06, 0xe6, 0x05, 0x68, 0x06, 0x48, 0xe6, 0x04, 0xe0, 0x07, 0x2f, 0x01, 0x6f,
+        0x01, 0x2f, 0x02, 0x41, 0x22, 0x41, 0x02, 0x0f, 0x01, 0x2f, 0x0c, 0x81, 0xaf, 0x01, 0x0f, 0x01,
+        0x0f, 0x01, 0x0f, 0x61, 0x0f, 0x02, 0x61, 0x02, 0x65, 0x02, 0x2f, 0x22, 0x21, 0x8c, 0x3f, 0x42,
+        0x0f, 0x0c, 0x2f, 0x02, 0x0f, 0xeb, 0x08, 0xea, 0x1b, 0x3f, 0x6a, 0x0b, 0x2f, 0x60, 0x8c, 0x8f,
+        0x2c, 0x6f, 0x0c, 0x2f, 0x0c, 0x2f, 0x0c, 0xcf, 0x0c, 0xef, 0x17, 0x2c, 0x2f, 0x0c, 0x0f, 0x0c,
+        0xef, 0x17, 0xec, 0x80, 0x84, 0xef, 0x00, 0x12, 0x13, 0x12, 0x13, 0xef, 0x0c, 0x2c, 0xcf, 0x12,
+        0x13, 0xef, 0x49, 0x0c, 0xef, 0x16, 0xec, 0x11, 0xef, 0x20, 0xac, 0xef, 0x40, 0xe0, 0x0e, 0xef,
+        0x03, 0xe0, 0x0d, 0xeb, 0x34, 0xef, 0x46, 0xeb, 0x0e, 0xef, 0x80, 0x2f, 0x0c, 0xef, 0x01, 0x0c,
+        0xef, 0x2e, 0xec, 0x00, 0xef, 0x67, 0x0c, 0xef, 0x80, 0x70, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+        0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xeb, 0x16, 0xef, 0x24, 0x8c, 0x12, 0x13, 0xec,
+        0x17, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xec, 0x08, 0xef, 0x80, 0x78,
+        0xec, 0x7b, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+        0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0xec, 0x37, 0x12, 0x13, 0x12, 0x13, 0xec, 0x18,
+        0x12, 0x13, 0xec, 0x80, 0x7a, 0xef, 0x28, 0xec, 0x0d, 0x2f, 0xac, 0xef, 0x1f, 0x20, 0xef, 0x80,
+        0x02, 0xe1, 0x28, 0xe2, 0x28, 0x5f, 0x21, 0x22, 0xdf, 0x41, 0x02, 0x3f, 0x02, 0x3f, 0x82, 0x24,
+        0x41, 0x02, 0xff, 0x5a, 0x02, 0xaf, 0x7f, 0x46, 0x3f, 0x80, 0x76, 0x0b, 0x36, 0xe2, 0x1e, 0x00,
+        0x02, 0x80, 0x02, 0x20, 0xe5, 0x30, 0xc0, 0x04, 0x16, 0xe0, 0x06, 0x06, 0xe5, 0x0f, 0xe0, 0x01,
+        0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00, 0xc5, 0x00,
+        0xe6, 0x18, 0x36, 0x14, 0x15, 0x14, 0x15, 0x56, 0x14, 0x15, 0x16, 0x14, 0x15, 0xf6, 0x01, 0x11,
+        0x36, 0x11, 0x16, 0x14, 0x15, 0x36, 0x14, 0x15, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13,
+        0x96, 0x04, 0xf6, 0x02, 0x31, 0x76, 0x11, 0x16, 0x12, 0xf6, 0x05, 0x2f, 0x56, 0x12, 0x13, 0x12,
+        0x13, 0x12, 0x13, 0x12, 0x13, 0x11, 0xe0, 0x1a, 0xef, 0x12, 0x00, 0xef, 0x51, 0xe0, 0x04, 0xef,
+        0x80, 0x4e, 0xe0, 0x12, 0xef, 0x08, 0x17, 0x56, 0x0f, 0x04, 0x05, 0x0a, 0x12, 0x13, 0x12, 0x13,
+        0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x2f, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x11,
+        0x12, 0x33, 0x0f, 0xea, 0x01, 0x66, 0x27, 0x11, 0x84, 0x2f, 0x4a, 0x04, 0x05, 0x16, 0x2f, 0x00,
+        0xe5, 0x4e, 0x20, 0x26, 0x2e, 0x24, 0x05, 0x11, 0xe5, 0x52, 0x16, 0x44, 0x05, 0x80, 0xe5, 0x23,
+        0x00, 0xe5, 0x56, 0x00, 0x2f, 0x6b, 0xef, 0x02, 0xe5, 0x18, 0xef, 0x1e, 0xe0, 0x01, 0x0f, 0xe5,
+        0x08, 0xef, 0x17, 0x00, 0xeb, 0x02, 0xef, 0x16, 0xeb, 0x00, 0x0f, 0xeb, 0x07, 0xef, 0x18, 0xeb,
+        0x02, 0xef, 0x1f, 0xeb, 0x07, 0xef, 0x80, 0xb8, 0xe5, 0x99, 0x38, 0xef, 0x38, 0xe5, 0xc0, 0x11,
+        0x8d, 0x04, 0xe5, 0x83, 0xef, 0x40, 0xef, 0x2f, 0xe0, 0x01, 0xe5, 0x20, 0xa4, 0x36, 0xe5, 0x80,
+        0x84, 0x04, 0x56, 0xe5, 0x08, 0xe9, 0x02, 0x25, 0xe0, 0x0c, 0xff, 0x26, 0x05, 0x06, 0x48, 0x16,
+        0xe6, 0x02, 0x16, 0x04, 0xff, 0x14, 0x24, 0x26, 0xe5, 0x3e, 0xea, 0x02, 0x26, 0xb6, 0xe0, 0x00,
+        0xee, 0x0f, 0xe4, 0x01, 0x2e, 0xff, 0x06, 0x22, 0xff, 0x36, 0x04, 0xe2, 0x00, 0x9f, 0xff, 0x02,
+        0x04, 0x2e, 0x7f, 0x05, 0x7f, 0x22, 0xff, 0x0d, 0x61, 0x02, 0x81, 0x02, 0xff, 0x07, 0x41, 0x02,
+        0x5f, 0xff, 0x09, 0xe0, 0x0c, 0x64, 0x3f, 0x05, 0x24, 0x02, 0xc5, 0x06, 0x45, 0x06, 0x65, 0x06,
+        0xe5, 0x0f, 0x27, 0x26, 0x07, 0x6f, 0x06, 0x40, 0xab, 0x2f, 0x0d, 0x0f, 0xa0, 0xe5, 0x2c, 0x76,
+        0xe0, 0x00, 0x27, 0xe5, 0x2a, 0xe7, 0x08, 0x26, 0xe0, 0x00, 0x36, 0xe9, 0x02, 0xa0, 0xe6, 0x0a,
+        0xa5, 0x56, 0x05, 0x16, 0x25, 0x06, 0xe9, 0x02, 0xe5, 0x14, 0xe6, 0x00, 0x36, 0xe5, 0x0f, 0xe6,
+        0x03, 0x27, 0xe0, 0x03, 0x16, 0xe5, 0x15, 0x40, 0x46, 0x07, 0xe5, 0x27, 0x06, 0x27, 0x66, 0x27,
+        0x26, 0x47, 0xf6, 0x05, 0x00, 0x04, 0xe9, 0x02, 0x60, 0x36, 0x85, 0x06, 0x04, 0xe5, 0x01, 0xe9,
+        0x02, 0x85, 0x00, 0xe5, 0x21, 0xa6, 0x27, 0x26, 0x27, 0x26, 0xe0, 0x01, 0x45, 0x06, 0xe5, 0x00,
+        0x06, 0x07, 0x20, 0xe9, 0x02, 0x20, 0x76, 0xe5, 0x08, 0x04, 0xa5, 0x4f, 0x05, 0x07, 0x06, 0x07,
+        0xe5, 0x2a, 0x06, 0x05, 0x46, 0x25, 0x26, 0x85, 0x26, 0x05, 0x06, 0x05, 0xe0, 0x10, 0x25, 0x04,
+        0x36, 0xe5, 0x03, 0x07, 0x26, 0x27, 0x36, 0x05, 0x24, 0x07, 0x06, 0xe0, 0x02, 0xa5, 0x20, 0xa5,
+        0x20, 0xa5, 0xe0, 0x01, 0xc5, 0x00, 0xc5, 0x00, 0xe2, 0x23, 0x0e, 0x64, 0xe2, 0x01, 0x04, 0x2e,
+        0x60, 0xe2, 0x48, 0xe5, 0x1b, 0x27, 0x06, 0x27, 0x06, 0x27, 0x16, 0x07, 0x06, 0x20, 0xe9, 0x02,
+        0xa0, 0xe5, 0xab, 0x1c, 0xe0, 0x04, 0xe5, 0x0f, 0x60, 0xe5, 0x29, 0x60, 0xfc, 0x87, 0x78, 0xfd,
+        0x98, 0x78, 0xe5, 0x80, 0xe6, 0x20, 0xe5, 0x62, 0xe0, 0x1e, 0xc2, 0xe0, 0x04, 0x82, 0x80, 0x05,
+        0x06, 0xe5, 0x02, 0x0c, 0xe5, 0x05, 0x00, 0x85, 0x00, 0x05, 0x00, 0x25, 0x00, 0x25, 0x00, 0xe5,
+        0x64, 0xee, 0x09, 0xef, 0x08, 0xe5, 0x80, 0xe3, 0x13, 0x12, 0xef, 0x08, 0xe5, 0x38, 0x2f, 0xe5,
+        0x2e, 0xef, 0x00, 0xe0, 0x18, 0xe5, 0x04, 0x0d, 0x4f, 0xe6, 0x08, 0xd6, 0x12, 0x13, 0x16, 0xa0,
+        0xe6, 0x08, 0x16, 0x31, 0x30, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12, 0x13, 0x12,
+        0x13, 0x12, 0x13, 0x12, 0x13, 0x36, 0x12, 0x13, 0x76, 0x50, 0x56, 0x00, 0x76, 0x11, 0x12, 0x13,
+        0x12, 0x13, 0x12, 0x13, 0x56, 0x0c, 0x11, 0x4c, 0x00, 0x16, 0x0d, 0x36, 0x60, 0x85, 0x00, 0xe5,
+        0x7f, 0x20, 0x1b, 0x00, 0x56, 0x0d, 0x56, 0x12, 0x13, 0x16, 0x0c, 0x16, 0x11, 0x36, 0xe9, 0x02,
+        0x36, 0x4c, 0x36, 0xe1, 0x12, 0x12, 0x16, 0x13, 0x0e, 0x10, 0x0e, 0xe2, 0x12, 0x12, 0x0c, 0x13,
+        0x0c, 0x12, 0x13, 0x16, 0x12, 0x13, 0x36, 0xe5, 0x02, 0x04, 0xe5, 0x25, 0x24, 0xe5, 0x17, 0x40,
+        0xa5, 0x20, 0xa5, 0x20, 0xa5, 0x20, 0x45, 0x40, 0x2d, 0x0c, 0x0e, 0x0f, 0x2d, 0x00, 0x0f, 0x6c,
+        0x2f, 0xe0, 0x02, 0x5b, 0x2f, 0x20, 0xe5, 0x04, 0x00, 0xe5, 0x12, 0x00, 0xe5, 0x0b, 0x00, 0x25,
+        0x00, 0xe5, 0x07, 0x20, 0xe5, 0x06, 0xe0, 0x1a, 0xe5, 0x73, 0x80, 0x56, 0x60, 0xeb, 0x25, 0x40,
+        0xef, 0x01, 0xea, 0x2d, 0x6b, 0xef, 0x09, 0x2b, 0x4f, 0x00, 0xef, 0x05, 0x40, 0x0f, 0xe0, 0x27,
+        0xef, 0x25, 0x06, 0xe0, 0x7a, 0xe5, 0x15, 0x40, 0xe5, 0x29, 0xe0, 0x07, 0x06, 0xeb, 0x13, 0x60,
+        0xe5, 0x18, 0x6b, 0xe0, 0x01, 0xe5, 0x0c, 0x0a, 0xe5, 0x00, 0x0a, 0x80, 0xe5, 0x1e, 0x86, 0x80,
+        0xe5, 0x16, 0x00, 0x16, 0xe5, 0x1c, 0x60, 0xe5, 0x00, 0x16, 0x8a, 0xe0, 0x22, 0xe1, 0x20, 0xe2,
+        0x20, 0xe5, 0x46, 0x20, 0xe9, 0x02, 0xa0, 0xe1, 0x1c, 0x60, 0xe2, 0x1c, 0x60, 0xe5, 0x20, 0xe0,
+        0x00, 0xe5, 0x2c, 0xe0, 0x03, 0x16, 0xe1, 0x03, 0x00, 0xe1, 0x07, 0x00, 0xc1, 0x00, 0x21, 0x00,
+        0xe2, 0x03, 0x00, 0xe2, 0x07, 0x00, 0xc2, 0x00, 0x22, 0x40, 0xe5, 0x2c, 0xe0, 0x04, 0xe5, 0x80,
+        0xaf, 0xe0, 0x01, 0xe5, 0x0e, 0xe0, 0x02, 0xe5, 0x00, 0xe0, 0x10, 0xa4, 0x00, 0xe4, 0x22, 0x00,
+        0xe4, 0x01, 0xe0, 0x3d, 0xa5, 0x20, 0x05, 0x00, 0xe5, 0x24, 0x00, 0x25, 0x40, 0x05, 0x20, 0xe5,
+        0x0f, 0x00, 0x16, 0xeb, 0x00, 0xe5, 0x0f, 0x2f, 0xcb, 0xe5, 0x17, 0xe0, 0x00, 0xeb, 0x01, 0xe0,
+        0x28, 0xe5, 0x0b, 0x00, 0x25, 0x80, 0x8b, 0xe5, 0x0e, 0xab, 0x40, 0x16, 0xe5, 0x12, 0x80, 0x16,
+        0xe5, 0x12, 0xe0, 0x1e, 0xe5, 0x30, 0x60, 0x2b, 0x25, 0xeb, 0x08, 0x20, 0xeb, 0x26, 0x05, 0x46,
+        0x00, 0x26, 0x80, 0x66, 0x65, 0x00, 0x45, 0x00, 0xe5, 0x15, 0x20, 0x46, 0x60, 0x06, 0xeb, 0x01,
+        0xc0, 0xf6, 0x01, 0xc0, 0xe5, 0x15, 0x2b, 0x16, 0xe5, 0x15, 0x4b, 0xe0, 0x18, 0xe5, 0x00, 0x0f,
+        0xe5, 0x14, 0x26, 0x60, 0x8b, 0xd6, 0xe0, 0x01, 0xe5, 0x2e, 0x40, 0xd6, 0xe5, 0x0e, 0x20, 0xeb,
+        0x00, 0xe5, 0x0b, 0x80, 0xeb, 0x00, 0xe5, 0x0a, 0xc0, 0x76, 0xe0, 0x04, 0xcb, 0xe0, 0x48, 0xe5,
+        0x41, 0xe0, 0x2f, 0xe1, 0x2b, 0xe0, 0x05, 0xe2, 0x2b, 0xc0, 0xab, 0xe5, 0x1c, 0x66, 0xe0, 0x00,
+        0xe9, 0x02, 0xa0, 0xe9, 0x02, 0x65, 0x04, 0x05, 0xe1, 0x0e, 0x40, 0x86, 0x11, 0x04, 0xe2, 0x0e,
+        0xe0, 0x00, 0x2c, 0xe0, 0x80, 0x48, 0xeb, 0x17, 0x00, 0xe5, 0x22, 0x00, 0x26, 0x11, 0x20, 0x25,
+        0xe0, 0x08, 0x45, 0x04, 0x25, 0xe0, 0x00, 0x16, 0xef, 0x00, 0xe0, 0x19, 0xa6, 0xe5, 0x15, 0xeb,
+        0x02, 0x05, 0xe0, 0x00, 0xe5, 0x0e, 0xe6, 0x03, 0x6b, 0x96, 0xe0, 0x0e, 0xe5, 0x0a, 0x66, 0x76,
+        0xe0, 0x1e, 0xe5, 0x0d, 0xcb, 0xe0, 0x0c, 0xe5, 0x0f, 0xe0, 0x01, 0x07, 0x06, 0x07, 0xe5, 0x2d,
+        0xe6, 0x07, 0xd6, 0x60, 0xeb, 0x0c, 0xe9, 0x02, 0x06, 0x25, 0x26, 0x05, 0xe0, 0x01, 0x46, 0x07,
+        0xe5, 0x25, 0x47, 0x66, 0x27, 0x26, 0x36, 0x1b, 0x76, 0x06, 0xe0, 0x02, 0x1b, 0x20, 0xe5, 0x11,
+        0xc0, 0xe9, 0x02, 0xa0, 0x46, 0xe5, 0x1c, 0x86, 0x07, 0xe6, 0x00, 0x00, 0xe9, 0x02, 0x76, 0x05,
+        0x27, 0x05, 0xe0, 0x00, 0xe5, 0x1b, 0x06, 0x36, 0x05, 0xe0, 0x01, 0x26, 0x07, 0xe5, 0x28, 0x47,
+        0xe6, 0x01, 0x27, 0x65, 0x76, 0x66, 0x16, 0x07, 0x06, 0xe9, 0x02, 0x05, 0x16, 0x05, 0x56, 0x00,
+        0xeb, 0x0c, 0xe0, 0x03, 0xe5, 0x0a, 0x00, 0xe5, 0x11, 0x47, 0x46, 0x27, 0x06, 0x07, 0x26, 0xb6,
+        0x06, 0x25, 0x06, 0xe0, 0x36, 0xc5, 0x00, 0x05, 0x00, 0x65, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x02,
+        0x16, 0xa0, 0xe5, 0x27, 0x06, 0x47, 0xe6, 0x00, 0x80, 0xe9, 0x02, 0xa0, 0x26, 0x27, 0x00, 0xe5,
+        0x00, 0x20, 0x25, 0x20, 0xe5, 0x0e, 0x00, 0xc5, 0x00, 0x25, 0x00, 0x85, 0x00, 0x26, 0x05, 0x27,
+        0x06, 0x67, 0x20, 0x27, 0x20, 0x47, 0x20, 0x05, 0xa0, 0x07, 0x80, 0x85, 0x27, 0x20, 0xc6, 0x40,
+        0x86, 0xe0, 0x03, 0xe5, 0x02, 0x00, 0x05, 0x20, 0x05, 0x00, 0xe5, 0x1e, 0x00, 0x05, 0x47, 0xa6,
+        0x00, 0x07, 0x20, 0x07, 0x00, 0x67, 0x00, 0x27, 0x06, 0x07, 0x06, 0x05, 0x06, 0x05, 0x36, 0x00,
+        0x36, 0xe0, 0x00, 0x26, 0xe0, 0x15, 0xe5, 0x2d, 0x47, 0xe6, 0x00, 0x27, 0x46, 0x07, 0x06, 0x65,
+        0x96, 0xe9, 0x02, 0x36, 0x00, 0x16, 0x06, 0x45, 0xe0, 0x16, 0xe5, 0x28, 0x47, 0xa6, 0x07, 0x06,
+        0x67, 0x26, 0x07, 0x26, 0x25, 0x16, 0x05, 0xe0, 0x00, 0xe9, 0x02, 0xe0, 0x80, 0x1e, 0xe5, 0x27,
+        0x47, 0x66, 0x20, 0x67, 0x26, 0x07, 0x26, 0xf6, 0x0f, 0x65, 0x26, 0xe0, 0x1a, 0xe5, 0x28, 0x47,
+        0xe6, 0x00, 0x27, 0x06, 0x07, 0x26, 0x56, 0x05, 0xe0, 0x03, 0xe9, 0x02, 0xa0, 0xf6, 0x05, 0xe0,
+        0x0b, 0xe5, 0x23, 0x06, 0x07, 0x06, 0x27, 0xa6, 0x07, 0x06, 0x05, 0x16, 0xa0, 0xe9, 0x02, 0xa0,
+        0xe9, 0x0c, 0xe0, 0x14, 0xe5, 0x13, 0x20, 0x06, 0x07, 0x06, 0x27, 0x66, 0x07, 0x86, 0x60, 0xe9,
+        0x02, 0x2b, 0x56, 0x0f, 0xc5, 0xe0, 0x80, 0x31, 0xe5, 0x24, 0x47, 0xe6, 0x01, 0x07, 0x26, 0x16,
+        0xe0, 0x5c, 0xe1, 0x18, 0xe2, 0x18, 0xe9, 0x02, 0xeb, 0x01, 0xe0, 0x04, 0xe5, 0x00, 0x20, 0x05,
+        0x20, 0xe5, 0x00, 0x00, 0x25, 0x00, 0xe5, 0x10, 0xa7, 0x00, 0x27, 0x20, 0x26, 0x07, 0x06, 0x05,
+        0x07, 0x05, 0x07, 0x06, 0x56, 0xe0, 0x01, 0xe9, 0x02, 0xe0, 0x3e, 0xe5, 0x00, 0x20, 0xe5, 0x1f,
+        0x47, 0x66, 0x20, 0x26, 0x67, 0x06, 0x05, 0x16, 0x05, 0x07, 0xe0, 0x13, 0x05, 0xe6, 0x02, 0xe5,
+        0x20, 0xa6, 0x07, 0x05, 0x66, 0xf6, 0x00, 0x06, 0xe0, 0x00, 0x05, 0xa6, 0x27, 0x46, 0xe5, 0x26,
+        0xe6, 0x05, 0x07, 0x26, 0x56, 0x05, 0x96, 0xe0, 0x05, 0xe5, 0x41, 0xc0, 0xf6, 0x02, 0xe0, 0x4e,
+        0x06, 0x07, 0x46, 0x07, 0x06, 0x07, 0xe0, 0x50, 0xe5, 0x19, 0x16, 0xe0, 0x06, 0xe9, 0x02, 0xa0,
+        0xe5, 0x01, 0x00, 0xe5, 0x1d, 0x07, 0xc6, 0x00, 0xa6, 0x07, 0x06, 0x05, 0x96, 0xe0, 0x02, 0xe9,
+        0x02, 0xeb, 0x0b, 0x40, 0x36, 0xe5, 0x16, 0x20, 0xe6, 0x0e, 0x00, 0x07, 0xc6, 0x07, 0x26, 0x07,
+        0x26, 0xe0, 0x41, 0xc5, 0x00, 0x25, 0x00, 0xe5, 0x1e, 0xa6, 0x40, 0x06, 0x00, 0x26, 0x00, 0xc6,
+        0x05, 0x06, 0xe0, 0x00, 0xe9, 0x02, 0xa0, 0xa5, 0x00, 0x25, 0x00, 0xe5, 0x18, 0x87, 0x00, 0x26,
+        0x00, 0x27, 0x06, 0x07, 0x06, 0x05, 0xc0, 0xe9, 0x02, 0xa0, 0xe5, 0x21, 0x04, 0x25, 0x60, 0xe9,
+        0x02, 0xe0, 0x80, 0x6e, 0xe5, 0x0b, 0x26, 0x27, 0x36, 0xc0, 0x26, 0x05, 0x07, 0xe5, 0x05, 0x00,
+        0xe5, 0x1a, 0x27, 0x86, 0x40, 0x27, 0x06, 0x07, 0x06, 0xf6, 0x05, 0xe9, 0x02, 0x06, 0xe0, 0x4d,
+        0x05, 0xe0, 0x07, 0xeb, 0x0d, 0xef, 0x00, 0x6d, 0xef, 0x09, 0xe0, 0x05, 0x16, 0xe5, 0x83, 0x12,
+        0xe0, 0x5e, 0xea, 0x67, 0x00, 0x96, 0xe0, 0x03, 0xe5, 0x80, 0x3c, 0xe0, 0x89, 0xc4, 0xe5, 0x59,
+        0x36, 0xe0, 0x05, 0xe5, 0x83, 0xa8, 0xfb, 0x08, 0x06, 0xa5, 0xe6, 0x07, 0xe0, 0x02, 0xe5, 0x8f,
+        0x13, 0x80, 0xe5, 0x81, 0xbf, 0xe0, 0x9a, 0x31, 0xe5, 0x16, 0xe6, 0x04, 0x47, 0x46, 0xe9, 0x02,
+        0xe0, 0x86, 0x3e, 0xe5, 0x81, 0xb1, 0xc0, 0xe5, 0x17, 0x00, 0xe9, 0x02, 0x60, 0x36, 0xe5, 0x47,
+        0x00, 0xe9, 0x02, 0xa0, 0xe5, 0x16, 0x20, 0x86, 0x16, 0xe0, 0x02, 0xe5, 0x28, 0xc6, 0x96, 0x6f,
+        0x64, 0x16, 0x0f, 0xe0, 0x02, 0xe9, 0x02, 0x00, 0xcb, 0x00, 0xe5, 0x0d, 0x80, 0xe5, 0x0b, 0xe0,
+        0x81, 0x28, 0x44, 0xe5, 0x20, 0x24, 0x56, 0xe9, 0x02, 0xe0, 0x80, 0x3e, 0xe1, 0x18, 0xe2, 0x18,
+        0xeb, 0x0f, 0x76, 0x80, 0xe1, 0x11, 0x20, 0xe2, 0x11, 0xe0, 0x24, 0xe5, 0x43, 0x60, 0x06, 0x05,
+        0xe7, 0x2f, 0xc0, 0x66, 0xe4, 0x05, 0xe0, 0x38, 0x24, 0x16, 0x04, 0x06, 0xe0, 0x03, 0x27, 0x24,
+        0x4a, 0xe0, 0x01, 0xe5, 0x9c, 0x4e, 0xe0, 0x21, 0xe5, 0x18, 0xe0, 0x59, 0xe5, 0x6b, 0xe0, 0xa1,
+        0x75, 0x64, 0x00, 0xc4, 0x00, 0x24, 0x00, 0xe5, 0x80, 0x9b, 0xe0, 0x07, 0x05, 0xe0, 0x15, 0x45,
+        0x20, 0x05, 0xe0, 0x06, 0x65, 0xe0, 0x00, 0xe5, 0x81, 0x04, 0xe0, 0x88, 0x7c, 0xe5, 0x63, 0x80,
+        0xe5, 0x05, 0x40, 0xe5, 0x01, 0xc0, 0xe5, 0x02, 0x20, 0x0f, 0x26, 0x16, 0x7b, 0xe0, 0x8e, 0xd4,
+        0xef, 0x80, 0x68, 0xe9, 0x02, 0x4f, 0x40, 0xef, 0x81, 0x2c, 0xa0, 0xef, 0x0f, 0xe0, 0x07, 0xef,
+        0x08, 0x0c, 0xe0, 0x07, 0xe6, 0x26, 0x20, 0xe6, 0x0f, 0xe0, 0x01, 0xef, 0x6c, 0xe0, 0x34, 0xef,
+        0x80, 0x6e, 0xe0, 0x02, 0xef, 0x1f, 0x20, 0xef, 0x34, 0x27, 0x46, 0x4f, 0xa7, 0xfb, 0x00, 0xe6,
+        0x00, 0x2f, 0xc6, 0xef, 0x16, 0x66, 0xef, 0x35, 0xe0, 0x0d, 0xef, 0x3a, 0x46, 0x0f, 0xe0, 0x72,
+        0xeb, 0x0c, 0xe0, 0x04, 0xeb, 0x0c, 0xe0, 0x04, 0xef, 0x4f, 0xe0, 0x01, 0xeb, 0x11, 0xe0, 0x7f,
+        0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xc2, 0x00, 0xe2, 0x0a, 0xe1, 0x12, 0xe2, 0x12, 0x01, 0x00,
+        0x21, 0x20, 0x01, 0x20, 0x21, 0x20, 0x61, 0x00, 0xe1, 0x00, 0x62, 0x00, 0x02, 0x00, 0xc2, 0x00,
+        0xe2, 0x03, 0xe1, 0x12, 0xe2, 0x12, 0x21, 0x00, 0x61, 0x20, 0xe1, 0x00, 0x00, 0xc1, 0x00, 0xe2,
+        0x12, 0x21, 0x00, 0x61, 0x00, 0x81, 0x00, 0x01, 0x40, 0xc1, 0x00, 0xe2, 0x12, 0xe1, 0x12, 0xe2,
+        0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2, 0x12, 0xe1, 0x12, 0xe2,
+        0x12, 0xe1, 0x12, 0xe2, 0x14, 0x20, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c,
+        0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11,
+        0x0c, 0xa2, 0xe1, 0x11, 0x0c, 0xe2, 0x11, 0x0c, 0xa2, 0x3f, 0x20, 0xe9, 0x2a, 0xef, 0x81, 0x78,
+        0xe6, 0x2f, 0x6f, 0xe6, 0x2a, 0xef, 0x00, 0x06, 0xef, 0x06, 0x06, 0x2f, 0x96, 0xe0, 0x07, 0x86,
+        0x00, 0xe6, 0x07, 0xe0, 0x83, 0xc8, 0xe2, 0x02, 0x05, 0xe2, 0x0c, 0xa0, 0xa2, 0xe0, 0x80, 0x4d,
+        0xc6, 0x00, 0xe6, 0x09, 0x20, 0xc6, 0x00, 0x26, 0x00, 0x86, 0x80, 0xe4, 0x36, 0xe0, 0x19, 0x06,
+        0xe0, 0x68, 0xe5, 0x25, 0x40, 0xc6, 0xc4, 0x20, 0xe9, 0x02, 0x60, 0x05, 0x0f, 0xe0, 0x80, 0xb8,
+        0xe5, 0x16, 0x06, 0xe0, 0x09, 0xe5, 0x24, 0x66, 0xe9, 0x02, 0x80, 0x0d, 0xe0, 0x81, 0x48, 0xe5,
+        0x13, 0x04, 0x66, 0xe9, 0x02, 0xe0, 0x80, 0x4e, 0xe5, 0x16, 0x26, 0x05, 0xe9, 0x02, 0x60, 0x16,
+        0xe0, 0x80, 0x38, 0xe5, 0x17, 0x00, 0x45, 0x06, 0x25, 0x06, 0xc5, 0x26, 0x85, 0x06, 0xe0, 0x00,
+        0x05, 0x04, 0xe0, 0x80, 0x58, 0xc5, 0x00, 0x65, 0x00, 0x25, 0x00, 0xe5, 0x07, 0x00, 0xe5, 0x80,
+        0x3d, 0x20, 0xeb, 0x01, 0xc6, 0xe0, 0x21, 0xe1, 0x1a, 0xe2, 0x1a, 0xc6, 0x04, 0x60, 0xe9, 0x02,
+        0x60, 0x36, 0xe0, 0x82, 0x89, 0xeb, 0x33, 0x0f, 0x4b, 0x0d, 0x6b, 0xe0, 0x44, 0xeb, 0x25, 0x0f,
+        0xeb, 0x07, 0xe0, 0x80, 0x3a, 0x65, 0x00, 0xe5, 0x13, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00,
+        0xe5, 0x02, 0x00, 0x65, 0x00, 0x05, 0x00, 0x05, 0xa0, 0x05, 0x60, 0x05, 0x00, 0x05, 0x00, 0x05,
+        0x00, 0x45, 0x00, 0x25, 0x00, 0x05, 0x20, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05, 0x00, 0x05,
+        0x00, 0x25, 0x00, 0x05, 0x20, 0x65, 0x00, 0xc5, 0x00, 0x65, 0x00, 0x65, 0x00, 0x05, 0x00, 0xe5,
+        0x02, 0x00, 0xe5, 0x09, 0x80, 0x45, 0x00, 0x85, 0x00, 0xe5, 0x09, 0xe0, 0x2c, 0x2c, 0xe0, 0x80,
+        0x86, 0xef, 0x24, 0x60, 0xef, 0x5c, 0xe0, 0x04, 0xef, 0x07, 0x20, 0xef, 0x07, 0x00, 0xef, 0x07,
+        0x00, 0xef, 0x1d, 0xe0, 0x02, 0xeb, 0x05, 0xef, 0x80, 0x19, 0xe0, 0x30, 0xef, 0x15, 0xe0, 0x05,
+        0xef, 0x24, 0x60, 0xef, 0x01, 0xc0, 0x2f, 0xe0, 0x06, 0xaf, 0xe0, 0x80, 0x12, 0xef, 0x80, 0x73,
+        0x8e, 0xef, 0x82, 0x51, 0x40, 0xef, 0x09, 0x40, 0xef, 0x05, 0x40, 0xef, 0x80, 0x52, 0xa0, 0xef,
+        0x04, 0x60, 0x0f, 0xe0, 0x07, 0xef, 0x04, 0x60, 0xef, 0x30, 0xe0, 0x00, 0xef, 0x02, 0xa0, 0xef,
+        0x20, 0xe0, 0x00, 0xef, 0x16, 0x20, 0xef, 0x04, 0x60, 0x2f, 0xe0, 0x06, 0xec, 0x01, 0xe0, 0x1f,
+        0xef, 0x80, 0xd0, 0xe0, 0x00, 0xef, 0x06, 0x20, 0xef, 0x05, 0x40, 0xef, 0x03, 0x40, 0xef, 0x31,
+        0x00, 0x0f, 0x60, 0xef, 0x08, 0x20, 0xef, 0x04, 0x60, 0xef, 0x02, 0xc0, 0xef, 0x80, 0x0b, 0x00,
+        0xef, 0x54, 0xe9, 0x02, 0x0f, 0xe0, 0x83, 0x7d, 0xe5, 0xc0, 0x66, 0x58, 0xe0, 0x18, 0xe5, 0x90,
+        0x96, 0x20, 0xe5, 0x96, 0x06, 0x20, 0xe5, 0x9c, 0xa9, 0xe0, 0x07, 0xe5, 0x81, 0xe6, 0xe0, 0x89,
+        0x1a, 0xe5, 0x81, 0x96, 0xe0, 0x85, 0x5a, 0xe5, 0x92, 0xc3, 0x80, 0xe5, 0xa0, 0xa2, 0xe0, 0xca,
+        0x8a, 0xff, 0x1b, 0xe0, 0x16, 0xfb, 0x58, 0xe0, 0x78, 0xe6, 0x80, 0x68, 0xe0, 0xc0, 0xbd, 0x88,
+        0xfd, 0xc0, 0xbf, 0x76, 0x20, 0xfd, 0xc0, 0xbf, 0x76, 0x20,
+    };
+
+    // ---- Script tables ----
+    internal static ReadOnlySpan<byte> ScriptTable => new byte[]
+    {
+        0xc0, 0x1a, 0x99, 0x4c, 0x85, 0x1a, 0x99, 0x4c, 0xae, 0x1a, 0x80, 0x4c, 0x8e, 0x1a, 0x80, 0x4c,
+        0x84, 0x1a, 0x96, 0x4c, 0x80, 0x1a, 0x9e, 0x4c, 0x80, 0x1a, 0xe1, 0x60, 0x4c, 0xa6, 0x1a, 0x84,
+        0x4c, 0x84, 0x1a, 0x81, 0x0e, 0x93, 0x1a, 0xe0, 0x0f, 0x3b, 0x83, 0x2e, 0x80, 0x1a, 0x82, 0x2e,
+        0x01, 0x83, 0x2e, 0x80, 0x1a, 0x80, 0x2e, 0x03, 0x80, 0x2e, 0x80, 0x1a, 0x80, 0x2e, 0x80, 0x1a,
+        0x82, 0x2e, 0x00, 0x80, 0x2e, 0x00, 0x93, 0x2e, 0x00, 0xbe, 0x2e, 0x8d, 0x1b, 0x8f, 0x2e, 0xe0,
+        0x24, 0x1e, 0x81, 0x3b, 0xe0, 0x48, 0x1e, 0x00, 0xa5, 0x05, 0x01, 0xb1, 0x05, 0x01, 0x82, 0x05,
+        0x00, 0xb6, 0x38, 0x07, 0x9a, 0x38, 0x03, 0x85, 0x38, 0x0a, 0x84, 0x04, 0x80, 0x1a, 0x85, 0x04,
+        0x80, 0x1a, 0x8d, 0x04, 0x80, 0x1a, 0x82, 0x04, 0x80, 0x1a, 0x9f, 0x04, 0x80, 0x1a, 0x89, 0x04,
+        0x8a, 0x3b, 0x99, 0x04, 0x80, 0x3b, 0xe0, 0x0b, 0x04, 0x80, 0x1a, 0xa1, 0x04, 0x8d, 0x93, 0x00,
+        0xbb, 0x93, 0x01, 0x82, 0x93, 0xaf, 0x04, 0xb1, 0x9e, 0x0d, 0xba, 0x6b, 0x01, 0x82, 0x6b, 0xad,
+        0x85, 0x01, 0x8e, 0x85, 0x00, 0x9b, 0x57, 0x01, 0x80, 0x57, 0x00, 0x8a, 0x93, 0x04, 0xa1, 0x04,
+        0x04, 0xca, 0x04, 0x80, 0x1a, 0x9c, 0x04, 0xd0, 0x21, 0x83, 0x3b, 0x8e, 0x21, 0x81, 0x1a, 0x99,
+        0x21, 0x83, 0x0b, 0x00, 0x87, 0x0b, 0x01, 0x81, 0x0b, 0x01, 0x95, 0x0b, 0x00, 0x86, 0x0b, 0x00,
+        0x80, 0x0b, 0x02, 0x83, 0x0b, 0x01, 0x88, 0x0b, 0x01, 0x81, 0x0b, 0x01, 0x83, 0x0b, 0x07, 0x80,
+        0x0b, 0x03, 0x81, 0x0b, 0x00, 0x84, 0x0b, 0x01, 0x98, 0x0b, 0x01, 0x82, 0x31, 0x00, 0x85, 0x31,
+        0x03, 0x81, 0x31, 0x01, 0x95, 0x31, 0x00, 0x86, 0x31, 0x00, 0x81, 0x31, 0x00, 0x81, 0x31, 0x00,
+        0x81, 0x31, 0x01, 0x80, 0x31, 0x00, 0x84, 0x31, 0x03, 0x81, 0x31, 0x01, 0x82, 0x31, 0x02, 0x80,
+        0x31, 0x06, 0x83, 0x31, 0x00, 0x80, 0x31, 0x06, 0x90, 0x31, 0x09, 0x82, 0x2f, 0x00, 0x88, 0x2f,
+        0x00, 0x82, 0x2f, 0x00, 0x95, 0x2f, 0x00, 0x86, 0x2f, 0x00, 0x81, 0x2f, 0x00, 0x84, 0x2f, 0x01,
+        0x89, 0x2f, 0x00, 0x82, 0x2f, 0x00, 0x82, 0x2f, 0x01, 0x80, 0x2f, 0x0e, 0x83, 0x2f, 0x01, 0x8b,
+        0x2f, 0x06, 0x86, 0x2f, 0x00, 0x82, 0x7a, 0x00, 0x87, 0x7a, 0x01, 0x81, 0x7a, 0x01, 0x95, 0x7a,
+        0x00, 0x86, 0x7a, 0x00, 0x81, 0x7a, 0x00, 0x84, 0x7a, 0x01, 0x88, 0x7a, 0x01, 0x81, 0x7a, 0x01,
+        0x82, 0x7a, 0x06, 0x82, 0x7a, 0x03, 0x81, 0x7a, 0x00, 0x84, 0x7a, 0x01, 0x91, 0x7a, 0x09, 0x81,
+        0x9b, 0x00, 0x85, 0x9b, 0x02, 0x82, 0x9b, 0x00, 0x83, 0x9b, 0x02, 0x81, 0x9b, 0x00, 0x80, 0x9b,
+        0x00, 0x81, 0x9b, 0x02, 0x81, 0x9b, 0x02, 0x82, 0x9b, 0x02, 0x8b, 0x9b, 0x03, 0x84, 0x9b, 0x02,
+        0x82, 0x9b, 0x00, 0x83, 0x9b, 0x01, 0x80, 0x9b, 0x05, 0x80, 0x9b, 0x0d, 0x94, 0x9b, 0x04, 0x8c,
+        0x9d, 0x00, 0x82, 0x9d, 0x00, 0x96, 0x9d, 0x00, 0x8f, 0x9d, 0x01, 0x88, 0x9d, 0x00, 0x82, 0x9d,
+        0x00, 0x83, 0x9d, 0x06, 0x81, 0x9d, 0x00, 0x82, 0x9d, 0x00, 0x81, 0x9d, 0x01, 0x83, 0x9d, 0x01,
+        0x89, 0x9d, 0x06, 0x88, 0x9d, 0x8c, 0x40, 0x00, 0x82, 0x40, 0x00, 0x96, 0x40, 0x00, 0x89, 0x40,
+        0x00, 0x84, 0x40, 0x01, 0x88, 0x40, 0x00, 0x82, 0x40, 0x00, 0x83, 0x40, 0x06, 0x81, 0x40, 0x04,
+        0x82, 0x40, 0x00, 0x83, 0x40, 0x01, 0x89, 0x40, 0x00, 0x82, 0x40, 0x0b, 0x8c, 0x56, 0x00, 0x82,
+        0x56, 0x00, 0xb2, 0x56, 0x00, 0x82, 0x56, 0x00, 0x85, 0x56, 0x03, 0x8f, 0x56, 0x01, 0x99, 0x56,
+        0x00, 0x82, 0x8c, 0x00, 0x91, 0x8c, 0x02, 0x97, 0x8c, 0x00, 0x88, 0x8c, 0x00, 0x80, 0x8c, 0x01,
+        0x86, 0x8c, 0x02, 0x80, 0x8c, 0x03, 0x85, 0x8c, 0x00, 0x80, 0x8c, 0x00, 0x87, 0x8c, 0x05, 0x89,
+        0x8c, 0x01, 0x82, 0x8c, 0x0b, 0xb9, 0x9f, 0x03, 0x80, 0x1a, 0x9b, 0x9f, 0x24, 0x81, 0x4b, 0x00,
+        0x80, 0x4b, 0x00, 0x84, 0x4b, 0x00, 0x97, 0x4b, 0x00, 0x80, 0x4b, 0x00, 0x96, 0x4b, 0x01, 0x84,
+        0x4b, 0x00, 0x80, 0x4b, 0x00, 0x86, 0x4b, 0x00, 0x89, 0x4b, 0x01, 0x83, 0x4b, 0x1f, 0xc7, 0xa0,
+        0x00, 0xa3, 0xa0, 0x03, 0xa6, 0xa0, 0x00, 0xa3, 0xa0, 0x00, 0x8e, 0xa0, 0x00, 0x86, 0xa0, 0x83,
+        0x1a, 0x81, 0xa0, 0x24, 0xe0, 0x3f, 0x65, 0xa5, 0x29, 0x00, 0x80, 0x29, 0x04, 0x80, 0x29, 0x01,
+        0xaa, 0x29, 0x80, 0x1a, 0x83, 0x29, 0xe0, 0x9f, 0x34, 0xc8, 0x28, 0x00, 0x83, 0x28, 0x01, 0x86,
+        0x28, 0x00, 0x80, 0x28, 0x00, 0x83, 0x28, 0x01, 0xa8, 0x28, 0x00, 0x83, 0x28, 0x01, 0xa0, 0x28,
+        0x00, 0x83, 0x28, 0x01, 0x86, 0x28, 0x00, 0x80, 0x28, 0x00, 0x83, 0x28, 0x01, 0x8e, 0x28, 0x00,
+        0xb8, 0x28, 0x00, 0x83, 0x28, 0x01, 0xc2, 0x28, 0x01, 0x9f, 0x28, 0x02, 0x99, 0x28, 0x05, 0xd5,
+        0x18, 0x01, 0x85, 0x18, 0x01, 0xe2, 0x1f, 0x13, 0x9c, 0x6e, 0x02, 0xca, 0x84, 0x82, 0x1a, 0x8a,
+        0x84, 0x06, 0x95, 0x94, 0x08, 0x80, 0x94, 0x94, 0x36, 0x81, 0x1a, 0x08, 0x93, 0x12, 0x0b, 0x8c,
+        0x95, 0x00, 0x82, 0x95, 0x00, 0x81, 0x95, 0x0b, 0xdd, 0x46, 0x01, 0x89, 0x46, 0x05, 0x89, 0x46,
+        0x05, 0x81, 0x62, 0x81, 0x1a, 0x80, 0x62, 0x80, 0x1a, 0x93, 0x62, 0x05, 0xd8, 0x62, 0x06, 0xaa,
+        0x62, 0x04, 0xc5, 0x13, 0x09, 0x9e, 0x4e, 0x00, 0x8b, 0x4e, 0x03, 0x8b, 0x4e, 0x03, 0x80, 0x4e,
+        0x02, 0x8b, 0x4e, 0x9d, 0x96, 0x01, 0x84, 0x96, 0x0a, 0xab, 0x69, 0x03, 0x99, 0x69, 0x05, 0x8a,
+        0x69, 0x02, 0x81, 0x69, 0x9f, 0x46, 0x9b, 0x11, 0x01, 0x81, 0x11, 0xbe, 0x97, 0x00, 0x9c, 0x97,
+        0x01, 0x8a, 0x97, 0x05, 0x89, 0x97, 0x05, 0x8d, 0x97, 0x01, 0xad, 0x3b, 0x01, 0x8b, 0x3b, 0x13,
+        0xcc, 0x07, 0x00, 0xb1, 0x07, 0xbf, 0x90, 0xb3, 0x0a, 0x07, 0x83, 0x0a, 0xb7, 0x4d, 0x02, 0x8e,
+        0x4d, 0x02, 0x82, 0x4d, 0xaf, 0x6f, 0x8a, 0x1e, 0x04, 0xaa, 0x29, 0x01, 0x82, 0x29, 0x87, 0x90,
+        0x07, 0x82, 0x3b, 0x80, 0x1a, 0x8c, 0x3b, 0x80, 0x1a, 0x86, 0x3b, 0x83, 0x1a, 0x80, 0x3b, 0x85,
+        0x1a, 0x80, 0x3b, 0x82, 0x1a, 0x81, 0x3b, 0x80, 0x1a, 0x04, 0xa5, 0x4c, 0x84, 0x2e, 0x80, 0x1e,
+        0xb0, 0x4c, 0x84, 0x2e, 0x83, 0x4c, 0x84, 0x2e, 0x8c, 0x4c, 0x80, 0x1e, 0xc5, 0x4c, 0x80, 0x2e,
+        0xbf, 0x3b, 0xe0, 0x9f, 0x4c, 0x95, 0x2e, 0x01, 0x85, 0x2e, 0x01, 0xa5, 0x2e, 0x01, 0x85, 0x2e,
+        0x01, 0x87, 0x2e, 0x00, 0x80, 0x2e, 0x00, 0x80, 0x2e, 0x00, 0x80, 0x2e, 0x00, 0x9e, 0x2e, 0x01,
+        0xb4, 0x2e, 0x00, 0x8e, 0x2e, 0x00, 0x8d, 0x2e, 0x01, 0x85, 0x2e, 0x00, 0x92, 0x2e, 0x01, 0x82,
+        0x2e, 0x00, 0x88, 0x2e, 0x00, 0x8b, 0x1a, 0x81, 0x3b, 0xd6, 0x1a, 0x00, 0x8a, 0x1a, 0x80, 0x4c,
+        0x01, 0x8a, 0x1a, 0x80, 0x4c, 0x8e, 0x1a, 0x00, 0x8c, 0x4c, 0x02, 0xa1, 0x1a, 0x0d, 0xa0, 0x3b,
+        0x0e, 0xa5, 0x1a, 0x80, 0x2e, 0x82, 0x1a, 0x81, 0x4c, 0x85, 0x1a, 0x80, 0x4c, 0x9a, 0x1a, 0x80,
+        0x4c, 0x90, 0x1a, 0xa8, 0x4c, 0x82, 0x1a, 0x03, 0xe2, 0x39, 0x1a, 0x15, 0x8a, 0x1a, 0x14, 0xe3,
+        0x3f, 0x1a, 0xe0, 0x9f, 0x10, 0xe2, 0x13, 0x1a, 0x01, 0xe0, 0x29, 0x1a, 0xdf, 0x2a, 0x9f, 0x4c,
+        0xe0, 0x13, 0x1b, 0x04, 0x86, 0x1b, 0xa5, 0x29, 0x00, 0x80, 0x29, 0x04, 0x80, 0x29, 0x01, 0xb7,
+        0xa1, 0x06, 0x81, 0xa1, 0x0d, 0x80, 0xa1, 0x96, 0x28, 0x08, 0x86, 0x28, 0x00, 0x86, 0x28, 0x00,
+        0x86, 0x28, 0x00, 0x86, 0x28, 0x00, 0x86, 0x28, 0x00, 0x86, 0x28, 0x00, 0x86, 0x28, 0x00, 0x86,
+        0x28, 0x00, 0x9f, 0x1e, 0xdd, 0x1a, 0x21, 0x99, 0x33, 0x00, 0xd8, 0x33, 0x0b, 0xe0, 0x75, 0x33,
+        0x19, 0x94, 0x1a, 0x80, 0x33, 0x80, 0x1a, 0x80, 0x33, 0x98, 0x1a, 0x88, 0x33, 0x83, 0x3b, 0x81,
+        0x34, 0x87, 0x1a, 0x83, 0x33, 0x83, 0x1a, 0x00, 0xd5, 0x39, 0x01, 0x81, 0x3b, 0x81, 0x1a, 0x82,
+        0x39, 0x80, 0x1a, 0xd9, 0x41, 0x81, 0x1a, 0x82, 0x41, 0x04, 0xaa, 0x0e, 0x00, 0xdd, 0x34, 0x00,
+        0x8f, 0x1a, 0x9f, 0x0e, 0xa5, 0x1a, 0x08, 0x80, 0x1a, 0x8f, 0x41, 0x9e, 0x34, 0x00, 0xbf, 0x1a,
+        0x9e, 0x34, 0xd0, 0x1a, 0xae, 0x41, 0x80, 0x1a, 0xd7, 0x41, 0xe0, 0x47, 0x1a, 0xf0, 0x09, 0x5f,
+        0x33, 0xbf, 0x1a, 0xf0, 0x41, 0x9f, 0x33, 0xe4, 0x2c, 0xae, 0x02, 0xb6, 0xae, 0x08, 0xaf, 0x51,
+        0xe0, 0xcb, 0xa9, 0x13, 0xdf, 0x1e, 0xd7, 0x08, 0x07, 0xa1, 0x1a, 0xe0, 0x05, 0x4c, 0x82, 0x1a,
+        0xd1, 0x4c, 0x13, 0x8e, 0x4c, 0xac, 0x92, 0x02, 0x89, 0x1a, 0x05, 0xb7, 0x80, 0x07, 0xc5, 0x86,
+        0x07, 0x8b, 0x86, 0x05, 0x9f, 0x21, 0xad, 0x44, 0x80, 0x1a, 0x80, 0x44, 0xa3, 0x83, 0x0a, 0x80,
+        0x83, 0x9c, 0x34, 0x02, 0xcd, 0x3e, 0x00, 0x80, 0x1a, 0x89, 0x3e, 0x03, 0x81, 0x3e, 0x9e, 0x65,
+        0x00, 0xb6, 0x17, 0x08, 0x8d, 0x17, 0x01, 0x89, 0x17, 0x01, 0x83, 0x17, 0x9f, 0x65, 0xc2, 0x98,
+        0x17, 0x84, 0x98, 0x96, 0x5c, 0x09, 0x85, 0x28, 0x01, 0x85, 0x28, 0x01, 0x85, 0x28, 0x08, 0x86,
+        0x28, 0x00, 0x86, 0x28, 0x00, 0xaa, 0x4c, 0x80, 0x1a, 0x88, 0x4c, 0x80, 0x2e, 0x83, 0x4c, 0x81,
+        0x1a, 0x03, 0xcf, 0x18, 0xad, 0x5c, 0x01, 0x89, 0x5c, 0x05, 0xf0, 0x1b, 0x43, 0x34, 0x0b, 0x96,
+        0x34, 0x03, 0xb0, 0x34, 0x70, 0x10, 0xa3, 0xe1, 0x0d, 0x33, 0x01, 0xe0, 0x09, 0x33, 0x25, 0x86,
+        0x4c, 0x0b, 0x84, 0x05, 0x04, 0x99, 0x38, 0x00, 0x84, 0x38, 0x00, 0x80, 0x38, 0x00, 0x81, 0x38,
+        0x00, 0x81, 0x38, 0x00, 0x89, 0x38, 0xe1, 0x8d, 0x04, 0x81, 0x1a, 0xe0, 0x2f, 0x04, 0x1f, 0x8f,
+        0x04, 0x8f, 0x3b, 0x89, 0x1a, 0x05, 0x8d, 0x3b, 0x81, 0x1e, 0xa2, 0x1a, 0x00, 0x92, 0x1a, 0x00,
+        0x83, 0x1a, 0x03, 0x84, 0x04, 0x00, 0xe0, 0x26, 0x04, 0x01, 0x80, 0x1a, 0x00, 0x9f, 0x1a, 0x99,
+        0x4c, 0x85, 0x1a, 0x99, 0x4c, 0x8a, 0x1a, 0x89, 0x41, 0x80, 0x1a, 0xac, 0x41, 0x81, 0x1a, 0x9e,
+        0x34, 0x02, 0x85, 0x34, 0x01, 0x85, 0x34, 0x01, 0x85, 0x34, 0x01, 0x82, 0x34, 0x02, 0x86, 0x1a,
+        0x00, 0x86, 0x1a, 0x09, 0x84, 0x1a, 0x01, 0x8b, 0x50, 0x00, 0x99, 0x50, 0x00, 0x92, 0x50, 0x00,
+        0x81, 0x50, 0x00, 0x8e, 0x50, 0x01, 0x8d, 0x50, 0x21, 0xe0, 0x1a, 0x50, 0x04, 0x82, 0x1a, 0x03,
+        0xac, 0x1a, 0x02, 0x88, 0x1a, 0xce, 0x2e, 0x00, 0x8c, 0x1a, 0x02, 0x80, 0x2e, 0x2e, 0xac, 0x1a,
+        0x80, 0x3b, 0x60, 0x21, 0x9c, 0x52, 0x02, 0xb0, 0x14, 0x0e, 0x80, 0x3b, 0x9a, 0x1a, 0x03, 0xa3,
+        0x72, 0x08, 0x82, 0x72, 0x9a, 0x2b, 0x04, 0xaa, 0x74, 0x04, 0x9d, 0xa8, 0x00, 0x80, 0xa8, 0xa3,
+        0x75, 0x03, 0x8d, 0x75, 0x29, 0xcf, 0x20, 0xaf, 0x88, 0x9d, 0x7c, 0x01, 0x89, 0x7c, 0x05, 0xa3,
+        0x7b, 0x03, 0xa3, 0x7b, 0x03, 0xa7, 0x26, 0x07, 0xb3, 0x15, 0x0a, 0x80, 0x15, 0x8a, 0xaa, 0x00,
+        0x8e, 0xaa, 0x00, 0x86, 0xaa, 0x00, 0x81, 0xaa, 0x00, 0x8a, 0xaa, 0x00, 0x8e, 0xaa, 0x00, 0x86,
+        0xaa, 0x00, 0x81, 0xaa, 0x02, 0xb3, 0xa4, 0x0b, 0xe0, 0xd6, 0x4f, 0x08, 0x95, 0x4f, 0x09, 0x87,
+        0x4f, 0x17, 0x85, 0x4c, 0x00, 0xa9, 0x4c, 0x00, 0x88, 0x4c, 0x44, 0x85, 0x1d, 0x01, 0x80, 0x1d,
+        0x00, 0xab, 0x1d, 0x00, 0x81, 0x1d, 0x02, 0x80, 0x1d, 0x01, 0x80, 0x1d, 0x95, 0x3a, 0x00, 0x88,
+        0x3a, 0x9f, 0x7e, 0x9e, 0x66, 0x07, 0x88, 0x66, 0x2f, 0x92, 0x37, 0x00, 0x81, 0x37, 0x04, 0x84,
+        0x37, 0x9b, 0x81, 0x02, 0x80, 0x81, 0x99, 0x53, 0x04, 0x80, 0x53, 0x99, 0x8a, 0x25, 0x9f, 0x5f,
+        0x97, 0x5e, 0x03, 0x93, 0x5e, 0x01, 0xad, 0x5e, 0x83, 0x45, 0x00, 0x81, 0x45, 0x04, 0x87, 0x45,
+        0x00, 0x82, 0x45, 0x00, 0x9c, 0x45, 0x01, 0x82, 0x45, 0x03, 0x89, 0x45, 0x06, 0x88, 0x45, 0x06,
+        0x9f, 0x77, 0x9f, 0x73, 0x1f, 0xa6, 0x58, 0x03, 0x8b, 0x58, 0x08, 0xb5, 0x06, 0x02, 0x86, 0x06,
+        0x95, 0x3d, 0x01, 0x87, 0x3d, 0x92, 0x3c, 0x04, 0x87, 0x3c, 0x91, 0x82, 0x06, 0x83, 0x82, 0x0b,
+        0x86, 0x82, 0x4f, 0xc8, 0x78, 0x36, 0xb2, 0x71, 0x0c, 0xb2, 0x71, 0x06, 0x85, 0x71, 0xa7, 0x35,
+        0x07, 0x89, 0x35, 0x05, 0xa5, 0x2c, 0x02, 0x9c, 0x2c, 0x07, 0x81, 0x2c, 0x60, 0x6f, 0x9e, 0x04,
+        0x00, 0xa9, 0xad, 0x00, 0x82, 0xad, 0x01, 0x81, 0xad, 0x0f, 0x85, 0x04, 0x07, 0x88, 0x04, 0x20,
+        0x85, 0x04, 0xa7, 0x76, 0x07, 0xa9, 0x8d, 0x15, 0x99, 0x79, 0x25, 0x9b, 0x19, 0x13, 0x96, 0x27,
+        0x08, 0xcd, 0x0f, 0x03, 0xa3, 0x0f, 0x08, 0x80, 0x0f, 0xc2, 0x3f, 0x09, 0x80, 0x3f, 0x01, 0x98,
+        0x8e, 0x06, 0x89, 0x8e, 0x05, 0xb4, 0x16, 0x00, 0x91, 0x16, 0x07, 0xa6, 0x55, 0x08, 0xdf, 0x87,
+        0x00, 0x93, 0x8c, 0x0a, 0x91, 0x47, 0x00, 0xae, 0x47, 0x3d, 0x86, 0x64, 0x00, 0x80, 0x64, 0x00,
+        0x83, 0x64, 0x00, 0x8e, 0x64, 0x00, 0x8a, 0x64, 0x05, 0xba, 0x49, 0x04, 0x89, 0x49, 0x05, 0x83,
+        0x2d, 0x00, 0x87, 0x2d, 0x01, 0x81, 0x2d, 0x01, 0x95, 0x2d, 0x00, 0x86, 0x2d, 0x00, 0x81, 0x2d,
+        0x00, 0x84, 0x2d, 0x00, 0x80, 0x3b, 0x88, 0x2d, 0x01, 0x81, 0x2d, 0x01, 0x82, 0x2d, 0x01, 0x80,
+        0x2d, 0x05, 0x80, 0x2d, 0x04, 0x86, 0x2d, 0x01, 0x86, 0x2d, 0x02, 0x84, 0x2d, 0x0a, 0x89, 0xa7,
+        0x00, 0x80, 0xa7, 0x01, 0x80, 0xa7, 0x00, 0xa5, 0xa7, 0x00, 0x89, 0xa7, 0x00, 0x80, 0xa7, 0x01,
+        0x80, 0xa7, 0x00, 0x83, 0xa7, 0x00, 0x89, 0xa7, 0x00, 0x81, 0xa7, 0x07, 0x81, 0xa7, 0x1c, 0xdb,
+        0x6a, 0x00, 0x84, 0x6a, 0x1d, 0xc7, 0xa2, 0x07, 0x89, 0xa2, 0x60, 0x45, 0xb5, 0x89, 0x01, 0xa5,
+        0x89, 0x21, 0xc4, 0x61, 0x0a, 0x89, 0x61, 0x05, 0x8c, 0x62, 0x12, 0xb9, 0x9a, 0x05, 0x89, 0x9a,
+        0x05, 0x93, 0x65, 0x1b, 0x9a, 0x02, 0x01, 0x8e, 0x02, 0x03, 0x96, 0x02, 0x60, 0x58, 0xbb, 0x23,
+        0x60, 0x03, 0xd2, 0xac, 0x0b, 0x80, 0xac, 0x86, 0x22, 0x01, 0x80, 0x22, 0x01, 0x87, 0x22, 0x00,
+        0x81, 0x22, 0x00, 0x9d, 0x22, 0x00, 0x81, 0x22, 0x01, 0x8b, 0x22, 0x08, 0x89, 0x22, 0x45, 0x87,
+        0x68, 0x01, 0xad, 0x68, 0x01, 0x8a, 0x68, 0x1a, 0xc7, 0xaf, 0x07, 0xd2, 0x8f, 0x0c, 0x8f, 0x13,
+        0xb8, 0x7f, 0x06, 0x89, 0x21, 0x55, 0x87, 0x87, 0x57, 0xa1, 0x91, 0x0d, 0x89, 0x91, 0x05, 0x88,
+        0x0d, 0x00, 0xac, 0x0d, 0x00, 0x8d, 0x0d, 0x09, 0x9c, 0x0d, 0x02, 0x9f, 0x59, 0x01, 0x95, 0x59,
+        0x00, 0x8d, 0x59, 0x48, 0x86, 0x5a, 0x00, 0x81, 0x5a, 0x00, 0xab, 0x5a, 0x02, 0x80, 0x5a, 0x00,
+        0x81, 0x5a, 0x00, 0x88, 0x5a, 0x07, 0x89, 0x5a, 0x05, 0x85, 0x30, 0x00, 0x81, 0x30, 0x00, 0xa4,
+        0x30, 0x00, 0x81, 0x30, 0x00, 0x85, 0x30, 0x06, 0x89, 0x30, 0x05, 0xab, 0xa5, 0x03, 0x89, 0xa5,
+        0x60, 0x95, 0x98, 0x54, 0x06, 0x90, 0x43, 0x00, 0xa8, 0x43, 0x02, 0x9c, 0x43, 0x54, 0x80, 0x51,
+        0x0e, 0xb1, 0x9b, 0x0c, 0x80, 0x9b, 0xe3, 0x39, 0x1c, 0x60, 0x05, 0xe0, 0x0e, 0x1c, 0x00, 0x84,
+        0x1c, 0x0a, 0xe0, 0x63, 0x1c, 0x69, 0xeb, 0xe0, 0x02, 0x1f, 0x0c, 0xe3, 0xf5, 0x25, 0x09, 0xef,
+        0x3a, 0x25, 0x04, 0xe1, 0xe6, 0x03, 0x70, 0x0a, 0x58, 0xb9, 0x32, 0x66, 0x65, 0xe1, 0xd8, 0x08,
+        0x06, 0x9e, 0x63, 0x00, 0x89, 0x63, 0x03, 0x81, 0x63, 0xce, 0xa3, 0x00, 0x89, 0xa3, 0x05, 0x9d,
+        0x09, 0x01, 0x85, 0x09, 0x09, 0xc5, 0x7d, 0x09, 0x89, 0x7d, 0x00, 0x86, 0x7d, 0x00, 0x94, 0x7d,
+        0x04, 0x92, 0x7d, 0x61, 0x4f, 0xb9, 0x4a, 0x60, 0x65, 0xda, 0x5b, 0x04, 0x98, 0x0c, 0x01, 0x98,
+        0x0c, 0x2b, 0xca, 0x60, 0x03, 0xb8, 0x60, 0x06, 0x90, 0x60, 0x3f, 0x80, 0x9c, 0x80, 0x6c, 0x81,
+        0x33, 0x80, 0x48, 0x0a, 0x86, 0x33, 0x08, 0xf0, 0x0a, 0x9f, 0x9c, 0xe1, 0x75, 0x48, 0x28, 0x80,
+        0x48, 0x9e, 0x9c, 0x60, 0x00, 0xe0, 0x12, 0x9c, 0x70, 0x11, 0x9c, 0x83, 0x41, 0x00, 0x86, 0x41,
+        0x00, 0x81, 0x41, 0x00, 0x80, 0x41, 0xe0, 0xbe, 0x39, 0x82, 0x41, 0x0e, 0x80, 0x39, 0x1c, 0x82,
+        0x39, 0x01, 0x80, 0x41, 0x0d, 0x83, 0x41, 0x07, 0xe1, 0x2b, 0x6c, 0x68, 0xa3, 0xe0, 0x0a, 0x24,
+        0x04, 0x8c, 0x24, 0x02, 0x88, 0x24, 0x06, 0x89, 0x24, 0x01, 0x83, 0x24, 0x83, 0x1a, 0x6e, 0xfb,
+        0xe0, 0x9c, 0x1a, 0x02, 0xe1, 0x53, 0x1a, 0x05, 0x96, 0x1a, 0x0e, 0x90, 0x1a, 0x0e, 0xad, 0x3b,
+        0x01, 0x96, 0x3b, 0x08, 0xe0, 0x13, 0x1a, 0x3b, 0xe0, 0x95, 0x1a, 0x09, 0xa6, 0x1a, 0x01, 0xbd,
+        0x1a, 0x82, 0x3b, 0x90, 0x1a, 0x87, 0x3b, 0x81, 0x1a, 0x86, 0x3b, 0x9d, 0x1a, 0x83, 0x3b, 0xbc,
+        0x1a, 0x14, 0xc5, 0x2e, 0x60, 0x19, 0x93, 0x1a, 0x0b, 0x93, 0x1a, 0x0b, 0xd6, 0x1a, 0x08, 0x98,
+        0x1a, 0x60, 0x26, 0xd4, 0x1a, 0x00, 0xc6, 0x1a, 0x00, 0x81, 0x1a, 0x01, 0x80, 0x1a, 0x01, 0x81,
+        0x1a, 0x01, 0x83, 0x1a, 0x00, 0x8b, 0x1a, 0x00, 0x80, 0x1a, 0x00, 0x86, 0x1a, 0x00, 0xc0, 0x1a,
+        0x00, 0x83, 0x1a, 0x01, 0x87, 0x1a, 0x00, 0x86, 0x1a, 0x00, 0x9b, 0x1a, 0x00, 0x83, 0x1a, 0x00,
+        0x84, 0x1a, 0x00, 0x80, 0x1a, 0x02, 0x86, 0x1a, 0x00, 0xe0, 0xf3, 0x1a, 0x01, 0xe0, 0xc3, 0x1a,
+        0x01, 0xb1, 0x1a, 0xe2, 0x2b, 0x8b, 0x0e, 0x84, 0x8b, 0x00, 0x8e, 0x8b, 0x63, 0xef, 0x9e, 0x4c,
+        0x05, 0x85, 0x4c, 0x60, 0x74, 0x86, 0x2a, 0x00, 0x90, 0x2a, 0x01, 0x86, 0x2a, 0x00, 0x81, 0x2a,
+        0x00, 0x84, 0x2a, 0x04, 0xbd, 0x1e, 0x20, 0x80, 0x1e, 0x60, 0x0f, 0xac, 0x6d, 0x02, 0x8d, 0x6d,
+        0x01, 0x89, 0x6d, 0x03, 0x81, 0x6d, 0x60, 0xdf, 0x9e, 0xa6, 0x10, 0xb9, 0xab, 0x04, 0x80, 0xab,
+        0x61, 0x6f, 0xa9, 0x67, 0x60, 0x75, 0xaa, 0x70, 0x03, 0x80, 0x70, 0x60, 0x5f, 0x9e, 0x99, 0x00,
+        0x95, 0x99, 0x07, 0x81, 0x99, 0x60, 0x7f, 0x86, 0x28, 0x00, 0x83, 0x28, 0x00, 0x81, 0x28, 0x00,
+        0x8e, 0x28, 0x00, 0xe0, 0x64, 0x5d, 0x01, 0x8f, 0x5d, 0x28, 0xcb, 0x01, 0x03, 0x89, 0x01, 0x03,
+        0x81, 0x01, 0x62, 0xb0, 0xc3, 0x1a, 0x4b, 0xbc, 0x1a, 0x60, 0x61, 0x83, 0x04, 0x00, 0x9a, 0x04,
+        0x00, 0x81, 0x04, 0x00, 0x80, 0x04, 0x01, 0x80, 0x04, 0x00, 0x89, 0x04, 0x00, 0x83, 0x04, 0x00,
+        0x80, 0x04, 0x00, 0x80, 0x04, 0x05, 0x80, 0x04, 0x03, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00, 0x80,
+        0x04, 0x00, 0x82, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04, 0x01, 0x80, 0x04, 0x00, 0x80, 0x04,
+        0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00, 0x80, 0x04, 0x00, 0x81, 0x04, 0x00, 0x80, 0x04, 0x01,
+        0x83, 0x04, 0x00, 0x86, 0x04, 0x00, 0x83, 0x04, 0x00, 0x83, 0x04, 0x00, 0x80, 0x04, 0x00, 0x89,
+        0x04, 0x00, 0x90, 0x04, 0x04, 0x82, 0x04, 0x00, 0x84, 0x04, 0x00, 0x90, 0x04, 0x33, 0x81, 0x04,
+        0x60, 0xad, 0xab, 0x1a, 0x03, 0xe0, 0x03, 0x1a, 0x0b, 0x8e, 0x1a, 0x01, 0x8e, 0x1a, 0x00, 0x8e,
+        0x1a, 0x00, 0xa4, 0x1a, 0x09, 0xe0, 0x4d, 0x1a, 0x37, 0x99, 0x1a, 0x80, 0x39, 0x81, 0x1a, 0x0c,
+        0xab, 0x1a, 0x03, 0x88, 0x1a, 0x06, 0x81, 0x1a, 0x0d, 0x85, 0x1a, 0x60, 0x39, 0xe3, 0x78, 0x1a,
+        0x02, 0x90, 0x1a, 0x02, 0x8c, 0x1a, 0x02, 0xe0, 0x79, 0x1a, 0x05, 0x8b, 0x1a, 0x03, 0x80, 0x1a,
+        0x0e, 0x8b, 0x1a, 0x03, 0xb7, 0x1a, 0x07, 0x89, 0x1a, 0x05, 0xa7, 0x1a, 0x07, 0x9d, 0x1a, 0x01,
+        0x8b, 0x1a, 0x03, 0x81, 0x1a, 0x0d, 0x88, 0x1a, 0x26, 0xe0, 0xf7, 0x1a, 0x07, 0x8d, 0x1a, 0x01,
+        0x8c, 0x1a, 0x02, 0x8a, 0x1a, 0x02, 0xb8, 0x1a, 0x00, 0x80, 0x1a, 0x03, 0x8f, 0x1a, 0x01, 0x8b,
+        0x1a, 0x03, 0x89, 0x1a, 0x06, 0xe0, 0x32, 0x1a, 0x00, 0xe0, 0x06, 0x1a, 0x63, 0xa4, 0xf0, 0x96,
+        0x7f, 0x33, 0x1f, 0xf0, 0x00, 0xbd, 0x33, 0x01, 0xf0, 0x06, 0x2d, 0x33, 0x01, 0xf0, 0x0c, 0xd0,
+        0x33, 0x0e, 0xe2, 0x0d, 0x33, 0x69, 0x41, 0xe1, 0xbd, 0x33, 0x65, 0x81, 0xf0, 0x02, 0xea, 0x33,
+        0x04, 0xf0, 0x10, 0xc9, 0x33, 0x7a, 0xbb, 0x26, 0x80, 0x1a, 0x1d, 0xdf, 0x1a, 0x60, 0x1f, 0xe0,
+        0x8f, 0x3b,
+    };
+
+    internal static ReadOnlySpan<byte> ScriptExtTable => new byte[]
+    {
+        0x80, 0x36, 0x00, 0x00, 0x10, 0x06, 0x14, 0x1b, 0x24, 0x26, 0x29, 0x2a, 0x30, 0x2b, 0x2e, 0x33,
+        0x4c, 0x53, 0x55, 0x74, 0x88, 0x81, 0x83, 0x00, 0x00, 0x07, 0x0b, 0x1e, 0x21, 0x4c, 0x51, 0x9f,
+        0xa6, 0x09, 0x00, 0x00, 0x02, 0x0e, 0x4c, 0x00, 0x00, 0x02, 0x02, 0x0e, 0x4c, 0x00, 0x00, 0x00,
+        0x02, 0x4c, 0x51, 0x08, 0x00, 0x00, 0x02, 0x4c, 0x9f, 0x00, 0x00, 0x00, 0x02, 0x0e, 0x4c, 0x25,
+        0x00, 0x00, 0x08, 0x18, 0x1b, 0x1e, 0x2e, 0x4c, 0x74, 0x91, 0x96, 0x00, 0x08, 0x18, 0x1e, 0x2e,
+        0x4c, 0x7b, 0x91, 0x96, 0xa4, 0x00, 0x04, 0x18, 0x1e, 0x4c, 0xa1, 0x00, 0x05, 0x2a, 0x4c, 0x91,
+        0x93, 0x9f, 0x00, 0x0b, 0x15, 0x18, 0x1b, 0x1e, 0x2b, 0x2e, 0x4c, 0x7b, 0x93, 0xa1, 0xa4, 0x00,
+        0x06, 0x1b, 0x26, 0x2a, 0x2b, 0x41, 0x4c, 0x00, 0x05, 0x1e, 0x2e, 0x4c, 0x74, 0xa1, 0x00, 0x09,
+        0x1b, 0x24, 0x38, 0x4c, 0x74, 0x93, 0x96, 0xa1, 0xa4, 0x00, 0x0b, 0x05, 0x1e, 0x24, 0x2b, 0x2e,
+        0x38, 0x4c, 0x74, 0x93, 0x96, 0xa1, 0x00, 0x02, 0x4c, 0xa1, 0x00, 0x03, 0x24, 0x4c, 0x93, 0x00,
+        0x04, 0x18, 0x1e, 0x4c, 0x7b, 0x00, 0x03, 0x18, 0x4c, 0x96, 0x00, 0x02, 0x4c, 0x91, 0x00, 0x02,
+        0x28, 0x4c, 0x00, 0x00, 0x00, 0x02, 0x4c, 0x91, 0x00, 0x03, 0x1e, 0x4c, 0xa4, 0x00, 0x00, 0x00,
+        0x04, 0x2e, 0x4c, 0x74, 0xa4, 0x0e, 0x00, 0x00, 0x06, 0x18, 0x24, 0x41, 0x4c, 0x93, 0xa1, 0x00,
+        0x04, 0x18, 0x24, 0x4c, 0x93, 0x00, 0x02, 0x4c, 0x93, 0x06, 0x00, 0x00, 0x03, 0x4c, 0x91, 0x93,
+        0x00, 0x02, 0x4c, 0x93, 0x00, 0x00, 0x00, 0x03, 0x18, 0x4c, 0x93, 0x00, 0x07, 0x15, 0x18, 0x2b,
+        0x4c, 0x91, 0x93, 0x9f, 0x0f, 0x00, 0x00, 0x01, 0x2e, 0x01, 0x00, 0x00, 0x01, 0x2e, 0x11, 0x00,
+        0x00, 0x02, 0x4c, 0x7b, 0x04, 0x00, 0x00, 0x03, 0x15, 0x4c, 0xa4, 0x03, 0x00, 0x0c, 0x01, 0x4c,
+        0x03, 0x00, 0x01, 0x02, 0x1b, 0x2e, 0x80, 0x8c, 0x00, 0x00, 0x02, 0x1e, 0x74, 0x00, 0x02, 0x1e,
+        0x2a, 0x01, 0x02, 0x1e, 0x4c, 0x00, 0x02, 0x1e, 0x2a, 0x80, 0x80, 0x00, 0x00, 0x03, 0x05, 0x29,
+        0x2a, 0x80, 0x01, 0x00, 0x00, 0x07, 0x04, 0x2c, 0x6b, 0x35, 0x93, 0x9e, 0xad, 0x0d, 0x00, 0x00,
+        0x07, 0x04, 0x2c, 0x6b, 0x35, 0x93, 0x9e, 0xad, 0x00, 0x03, 0x04, 0x93, 0x9e, 0x01, 0x00, 0x00,
+        0x08, 0x01, 0x04, 0x2c, 0x6b, 0x35, 0x93, 0x9e, 0xad, 0x1f, 0x00, 0x00, 0x09, 0x01, 0x04, 0x57,
+        0x58, 0x79, 0x82, 0x35, 0x8d, 0x93, 0x09, 0x00, 0x0a, 0x02, 0x04, 0x93, 0x09, 0x00, 0x09, 0x03,
+        0x04, 0x9e, 0xad, 0x05, 0x00, 0x00, 0x02, 0x04, 0x93, 0x62, 0x00, 0x00, 0x02, 0x04, 0x35, 0x81,
+        0xfb, 0x00, 0x00, 0x0f, 0x0b, 0x21, 0x2d, 0x2f, 0x31, 0x40, 0x4c, 0x56, 0x68, 0x6a, 0x7a, 0x87,
+        0x9b, 0x9d, 0xa2, 0x00, 0x0d, 0x0b, 0x21, 0x2d, 0x2f, 0x31, 0x40, 0x4c, 0x56, 0x6a, 0x7a, 0x9b,
+        0x9d, 0xa2, 0x10, 0x00, 0x00, 0x15, 0x0b, 0x21, 0x23, 0x30, 0x5a, 0x2d, 0x2f, 0x31, 0x40, 0x55,
+        0x56, 0x68, 0x70, 0x7a, 0x49, 0x8c, 0x92, 0x9a, 0x9b, 0x9d, 0xa2, 0x00, 0x17, 0x0b, 0x21, 0x23,
+        0x30, 0x5a, 0x2d, 0x2f, 0x32, 0x31, 0x40, 0x4e, 0x55, 0x56, 0x68, 0x70, 0x7a, 0x49, 0x8c, 0x92,
+        0x9a, 0x9b, 0x9d, 0xa2, 0x09, 0x04, 0x21, 0x23, 0x3f, 0x55, 0x75, 0x00, 0x09, 0x03, 0x0b, 0x16,
+        0x92, 0x75, 0x00, 0x09, 0x02, 0x31, 0x64, 0x75, 0x00, 0x09, 0x02, 0x2f, 0x47, 0x80, 0x75, 0x00,
+        0x0d, 0x02, 0x2d, 0x9b, 0x80, 0x71, 0x00, 0x09, 0x03, 0x40, 0x68, 0xa7, 0x82, 0xcf, 0x00, 0x09,
+        0x03, 0x16, 0x65, 0x96, 0x80, 0x30, 0x00, 0x00, 0x03, 0x29, 0x2a, 0x4c, 0x85, 0x6e, 0x00, 0x02,
+        0x01, 0x84, 0x46, 0x00, 0x01, 0x04, 0x12, 0x36, 0x95, 0x94, 0x80, 0x4a, 0x00, 0x01, 0x02, 0x62,
+        0x80, 0x00, 0x00, 0x00, 0x02, 0x62, 0x80, 0x84, 0x49, 0x00, 0x00, 0x04, 0x0b, 0x21, 0x2d, 0x40,
+        0x00, 0x01, 0x21, 0x00, 0x04, 0x0b, 0x21, 0x2d, 0x40, 0x00, 0x03, 0x21, 0x2d, 0x40, 0x00, 0x01,
+        0x21, 0x00, 0x05, 0x0b, 0x21, 0x6a, 0x9d, 0xa2, 0x00, 0x03, 0x0b, 0x21, 0x9d, 0x00, 0x03, 0x21,
+        0x6a, 0x87, 0x00, 0x04, 0x0b, 0x21, 0x6a, 0x9d, 0x00, 0x02, 0x21, 0x87, 0x00, 0x06, 0x21, 0x40,
+        0x56, 0x7a, 0x9b, 0x9d, 0x00, 0x01, 0x21, 0x01, 0x02, 0x21, 0x87, 0x01, 0x01, 0x21, 0x00, 0x02,
+        0x21, 0x87, 0x00, 0x02, 0x0b, 0x21, 0x00, 0x03, 0x21, 0x6a, 0xa2, 0x05, 0x01, 0x21, 0x00, 0x03,
+        0x21, 0x68, 0x6a, 0x00, 0x03, 0x0b, 0x21, 0x87, 0x00, 0x02, 0x21, 0x6a, 0x00, 0x01, 0x21, 0x00,
+        0x04, 0x0b, 0x21, 0x6a, 0x87, 0x03, 0x01, 0x21, 0x00, 0x0b, 0x0b, 0x21, 0x2d, 0x40, 0x56, 0x68,
+        0x7a, 0x8c, 0x9d, 0xa2, 0xa7, 0x00, 0x02, 0x21, 0x2d, 0x00, 0x04, 0x21, 0x2d, 0x40, 0xa7, 0x01,
+        0x02, 0x0b, 0x21, 0x00, 0x01, 0x0b, 0x01, 0x02, 0x21, 0x2d, 0x00, 0x01, 0x68, 0x80, 0x44, 0x00,
+        0x01, 0x01, 0x2e, 0x35, 0x00, 0x00, 0x03, 0x1e, 0x4c, 0x93, 0x00, 0x00, 0x00, 0x01, 0x93, 0x81,
+        0xb3, 0x00, 0x00, 0x03, 0x4c, 0x62, 0x80, 0x1e, 0x00, 0x00, 0x02, 0x01, 0x04, 0x09, 0x00, 0x00,
+        0x06, 0x14, 0x29, 0x2a, 0x71, 0x52, 0x78, 0x01, 0x00, 0x00, 0x04, 0x14, 0x2e, 0x71, 0x5f, 0x80,
+        0x11, 0x00, 0x00, 0x03, 0x21, 0x2d, 0x4c, 0x8c, 0xa5, 0x00, 0x00, 0x02, 0x1b, 0x4c, 0x17, 0x00,
+        0x00, 0x02, 0x06, 0x78, 0x00, 0x07, 0x06, 0x14, 0x29, 0x71, 0x3f, 0x53, 0x85, 0x09, 0x00, 0x00,
+        0x01, 0x24, 0x03, 0x00, 0x00, 0x03, 0x01, 0x04, 0x71, 0x00, 0x00, 0x00, 0x02, 0x1e, 0x2a, 0x81,
+        0x2b, 0x00, 0x0f, 0x02, 0x33, 0x9c, 0x00, 0x00, 0x00, 0x07, 0x0e, 0x34, 0x33, 0x39, 0x41, 0x62,
+        0xae, 0x00, 0x08, 0x0e, 0x34, 0x33, 0x39, 0x41, 0x62, 0x80, 0xae, 0x00, 0x05, 0x0e, 0x34, 0x33,
+        0x39, 0x41, 0x01, 0x00, 0x00, 0x01, 0x33, 0x00, 0x00, 0x01, 0x08, 0x0e, 0x34, 0x33, 0x39, 0x41,
+        0x62, 0xa0, 0xae, 0x01, 0x09, 0x0e, 0x34, 0x33, 0x39, 0x41, 0x51, 0x62, 0xa0, 0xae, 0x05, 0x06,
+        0x0e, 0x34, 0x33, 0x39, 0x41, 0xae, 0x00, 0x00, 0x00, 0x05, 0x0e, 0x34, 0x33, 0x39, 0x41, 0x07,
+        0x06, 0x0e, 0x34, 0x33, 0x39, 0x41, 0xae, 0x03, 0x05, 0x0e, 0x34, 0x33, 0x39, 0x41, 0x09, 0x00,
+        0x03, 0x02, 0x0e, 0x33, 0x01, 0x00, 0x00, 0x05, 0x0e, 0x34, 0x33, 0x39, 0x41, 0x04, 0x02, 0x39,
+        0x41, 0x00, 0x00, 0x00, 0x05, 0x0e, 0x34, 0x33, 0x39, 0x41, 0x03, 0x00, 0x01, 0x03, 0x33, 0x39,
+        0x41, 0x01, 0x01, 0x33, 0x58, 0x00, 0x03, 0x02, 0x39, 0x41, 0x02, 0x00, 0x00, 0x02, 0x39, 0x41,
+        0x59, 0x00, 0x00, 0x06, 0x0e, 0x34, 0x33, 0x39, 0x41, 0xae, 0x00, 0x02, 0x39, 0x41, 0x80, 0x12,
+        0x00, 0x0f, 0x01, 0x33, 0x1f, 0x00, 0x25, 0x01, 0x33, 0x08, 0x00, 0x00, 0x02, 0x33, 0x9c, 0x2f,
+        0x00, 0x27, 0x01, 0x33, 0x37, 0x00, 0x30, 0x01, 0x33, 0x0e, 0x00, 0x0b, 0x01, 0x33, 0x32, 0x00,
+        0x00, 0x01, 0x33, 0x57, 0x00, 0x18, 0x01, 0x33, 0x09, 0x00, 0x04, 0x01, 0x33, 0x5f, 0x00, 0x1e,
+        0x01, 0x33, 0xc0, 0x31, 0xef, 0x00, 0x00, 0x02, 0x1e, 0x2a, 0x80, 0x0f, 0x00, 0x07, 0x02, 0x33,
+        0x4c, 0x80, 0xa7, 0x00, 0x02, 0x10, 0x21, 0x23, 0x2f, 0x31, 0x47, 0x40, 0x3f, 0x55, 0x56, 0x61,
+        0x68, 0x87, 0x49, 0x9a, 0xa2, 0xa7, 0x02, 0x0f, 0x21, 0x23, 0x2f, 0x31, 0x47, 0x40, 0x3f, 0x55,
+        0x61, 0x68, 0x87, 0x49, 0x9a, 0xa2, 0xa7, 0x01, 0x0b, 0x21, 0x23, 0x2f, 0x31, 0x47, 0x3f, 0x55,
+        0x61, 0x49, 0x9a, 0xa2, 0x00, 0x0c, 0x21, 0x23, 0x2f, 0x31, 0x47, 0x3f, 0x55, 0x61, 0x87, 0x49,
+        0x9a, 0xa2, 0x00, 0x0b, 0x21, 0x23, 0x2f, 0x31, 0x47, 0x3f, 0x55, 0x61, 0x49, 0x9a, 0xa2, 0x80,
+        0x36, 0x00, 0x00, 0x03, 0x0b, 0x21, 0xa7, 0x00, 0x00, 0x00, 0x02, 0x21, 0x9b, 0x39, 0x00, 0x00,
+        0x03, 0x44, 0x4c, 0x65, 0x80, 0x1f, 0x00, 0x00, 0x02, 0x11, 0x3e, 0xc0, 0x12, 0xed, 0x00, 0x01,
+        0x02, 0x04, 0x6b, 0x80, 0x31, 0x00, 0x00, 0x02, 0x04, 0x9e, 0x09, 0x00, 0x00, 0x02, 0x04, 0x9e,
+        0x46, 0x00, 0x01, 0x05, 0x0e, 0x34, 0x33, 0x39, 0x41, 0x80, 0x99, 0x00, 0x04, 0x06, 0x0e, 0x34,
+        0x33, 0x39, 0x41, 0xae, 0x09, 0x00, 0x00, 0x02, 0x39, 0x41, 0x2c, 0x00, 0x01, 0x02, 0x39, 0x41,
+        0x80, 0xdf, 0x00, 0x01, 0x03, 0x1f, 0x1d, 0x50, 0x00, 0x02, 0x1d, 0x50, 0x03, 0x00, 0x2c, 0x03,
+        0x1d, 0x4f, 0x50, 0x02, 0x00, 0x08, 0x02, 0x1d, 0x50, 0x81, 0x1f, 0x00, 0x1b, 0x02, 0x04, 0x1b,
+        0x87, 0x75, 0x00, 0x00, 0x02, 0x58, 0x79, 0x87, 0x8d, 0x00, 0x00, 0x02, 0x2d, 0x9b, 0x00, 0x00,
+        0x00, 0x02, 0x2d, 0x9b, 0x36, 0x00, 0x01, 0x02, 0x2d, 0x9b, 0x8c, 0x12, 0x00, 0x01, 0x02, 0x2d,
+        0x9b, 0x00, 0x00, 0x00, 0x02, 0x2d, 0x9b, 0xc0, 0x5c, 0x4b, 0x00, 0x03, 0x01, 0x24, 0x96, 0x3b,
+        0x00, 0x11, 0x01, 0x33, 0x9e, 0x5d, 0x00, 0x01, 0x01, 0x33, 0xce, 0xcd, 0x2d, 0x00,
+    };
+
+    // ---- Emoji sequence tables ----
+    internal static ReadOnlySpan<byte> RgiEmojiZwjSequence => new byte[]
+    {
+        0x02, 0xb8, 0x19, 0x40, 0x86, 0x02, 0xd1, 0x39, 0xb0, 0x19, 0x02, 0x26, 0x39, 0x42, 0x86, 0x02,
+        0xb4, 0x36, 0x42, 0x86, 0x03, 0x68, 0x54, 0x64, 0x87, 0x68, 0x54, 0x02, 0xdc, 0x39, 0x42, 0x86,
+        0x02, 0xd1, 0x39, 0x73, 0x13, 0x02, 0x39, 0x39, 0x40, 0x86, 0x02, 0x69, 0x34, 0xbd, 0x19, 0x03,
+        0xb6, 0x36, 0x40, 0x86, 0xa1, 0x87, 0x03, 0x68, 0x74, 0x1d, 0x19, 0x68, 0x74, 0x03, 0x68, 0x34,
+        0xbd, 0x19, 0xa1, 0x87, 0x02, 0xf1, 0x7a, 0xf2, 0x7a, 0x02, 0xca, 0x33, 0x42, 0x86, 0x02, 0x69,
+        0x34, 0xb0, 0x19, 0x04, 0x68, 0x14, 0x68, 0x14, 0x67, 0x14, 0x66, 0x14, 0x02, 0xf9, 0x26, 0x42,
+        0x86, 0x03, 0x69, 0x74, 0x1d, 0x19, 0x69, 0x74, 0x03, 0xd1, 0x19, 0xbc, 0x19, 0xa1, 0x87, 0x02,
+        0x3c, 0x19, 0x40, 0x86, 0x02, 0x68, 0x34, 0xeb, 0x13, 0x02, 0xc3, 0x33, 0xa1, 0x87, 0x02, 0x70,
+        0x34, 0x40, 0x86, 0x02, 0xd4, 0x39, 0x42, 0x86, 0x02, 0xcf, 0x39, 0x42, 0x86, 0x03, 0xd1, 0x79,
+        0xef, 0x1a, 0xd1, 0x79, 0x03, 0x68, 0x74, 0xef, 0x1a, 0x68, 0x74, 0x03, 0x69, 0x74, 0xef, 0x1a,
+        0x69, 0x74, 0x02, 0x47, 0x36, 0x40, 0x86, 0x03, 0x68, 0x74, 0x30, 0x14, 0x68, 0x74, 0x02, 0x39,
+        0x39, 0x42, 0x86, 0x04, 0xd1, 0x79, 0x64, 0x87, 0x8b, 0x14, 0xd1, 0x79, 0x03, 0x69, 0x74, 0x30,
+        0x14, 0x69, 0x74, 0x02, 0xd1, 0x39, 0x95, 0x86, 0x02, 0x68, 0x34, 0x93, 0x13, 0x02, 0x69, 0x34,
+        0xed, 0x13, 0x02, 0xda, 0x39, 0x40, 0x86, 0x03, 0x69, 0x34, 0xaf, 0x19, 0xa1, 0x87, 0x02, 0xd1,
+        0x39, 0x93, 0x13, 0x03, 0xce, 0x39, 0x42, 0x86, 0xa1, 0x87, 0x03, 0xd1, 0x79, 0x64, 0x87, 0xd1,
+        0x79, 0x03, 0xc3, 0x33, 0x42, 0x86, 0xa1, 0x87, 0x03, 0x69, 0x74, 0x1d, 0x19, 0x68, 0x74, 0x02,
+        0x69, 0x34, 0x92, 0x16, 0x02, 0xd1, 0x39, 0x96, 0x86, 0x04, 0x69, 0x14, 0x64, 0x87, 0x8b, 0x14,
+        0x68, 0x14, 0x02, 0x47, 0x36, 0x42, 0x86, 0x02, 0x68, 0x34, 0x7c, 0x13, 0x02, 0x86, 0x34, 0x42,
+        0x86, 0x02, 0xd1, 0x39, 0x7c, 0x13, 0x02, 0x69, 0x14, 0xa4, 0x13, 0x02, 0xda, 0x39, 0x42, 0x86,
+        0x02, 0x37, 0x39, 0x40, 0x86, 0x02, 0xd1, 0x39, 0x08, 0x87, 0x04, 0x68, 0x54, 0x64, 0x87, 0x8b,
+        0x14, 0x68, 0x54, 0x02, 0x4d, 0x36, 0x40, 0x86, 0x02, 0x68, 0x34, 0x2c, 0x15, 0x02, 0x69, 0x34,
+        0xaf, 0x19, 0x02, 0x6e, 0x34, 0x40, 0x86, 0x02, 0xcd, 0x39, 0x42, 0x86, 0x02, 0xd1, 0x39, 0x2c,
+        0x15, 0x02, 0x6f, 0x14, 0x40, 0x86, 0x03, 0xd1, 0x39, 0xbc, 0x19, 0xa1, 0x87, 0x02, 0x68, 0x34,
+        0xa8, 0x13, 0x02, 0x69, 0x34, 0x73, 0x13, 0x04, 0x69, 0x54, 0x64, 0x87, 0x8b, 0x14, 0x68, 0x54,
+        0x02, 0x71, 0x34, 0x42, 0x86, 0x02, 0x45, 0x36, 0x40, 0x86, 0x02, 0xd1, 0x39, 0xa8, 0x13, 0x03,
+        0x69, 0x54, 0x64, 0x87, 0x68, 0x54, 0x03, 0x69, 0x54, 0x64, 0x87, 0x69, 0x54, 0x03, 0xce, 0x39,
+        0x40, 0x86, 0xa1, 0x87, 0x02, 0xd8, 0x39, 0x40, 0x86, 0x03, 0xc3, 0x33, 0x40, 0x86, 0xa1, 0x87,
+        0x02, 0x4d, 0x36, 0x42, 0x86, 0x02, 0xd1, 0x19, 0x92, 0x16, 0x02, 0xd1, 0x39, 0xeb, 0x13, 0x02,
+        0x68, 0x34, 0xbc, 0x14, 0x02, 0xd1, 0x39, 0xbc, 0x14, 0x02, 0x3d, 0x39, 0x40, 0x86, 0x02, 0xb8,
+        0x39, 0x42, 0x86, 0x02, 0xa3, 0x36, 0x40, 0x86, 0x02, 0x75, 0x35, 0x40, 0x86, 0x02, 0xd8, 0x39,
+        0x42, 0x86, 0x02, 0x69, 0x34, 0x93, 0x13, 0x02, 0x35, 0x39, 0x40, 0x86, 0x02, 0x4b, 0x36, 0x40,
+        0x86, 0x02, 0x3d, 0x39, 0x42, 0x86, 0x02, 0x38, 0x39, 0x42, 0x86, 0x02, 0xa3, 0x36, 0x42, 0x86,
+        0x03, 0x69, 0x14, 0x67, 0x14, 0x67, 0x14, 0x02, 0xb6, 0x36, 0x40, 0x86, 0x02, 0x69, 0x34, 0x7c,
+        0x13, 0x02, 0x75, 0x35, 0x42, 0x86, 0x02, 0xcc, 0x93, 0x40, 0x86, 0x02, 0x6f, 0x34, 0x42, 0x86,
+        0x02, 0xcc, 0x33, 0x40, 0x86, 0x03, 0xd1, 0x39, 0xbd, 0x19, 0xa1, 0x87, 0x02, 0x87, 0x34, 0x40,
+        0x86, 0x02, 0x82, 0x34, 0x40, 0x86, 0x02, 0x69, 0x14, 0x3e, 0x13, 0x02, 0xd6, 0x39, 0x40, 0x86,
+        0x02, 0x68, 0x14, 0xbd, 0x19, 0x02, 0x4b, 0x36, 0x42, 0x86, 0x02, 0x46, 0x36, 0x42, 0x86, 0x02,
+        0x69, 0x34, 0x2c, 0x15, 0x03, 0xb6, 0x36, 0x42, 0x86, 0xa1, 0x87, 0x02, 0xc4, 0x33, 0x40, 0x86,
+        0x02, 0x26, 0x19, 0x40, 0x86, 0x02, 0x69, 0x14, 0xb0, 0x19, 0x02, 0xde, 0x19, 0x42, 0x86, 0x02,
+        0x69, 0x34, 0xa8, 0x13, 0x02, 0xcc, 0x33, 0x42, 0x86, 0x02, 0x82, 0x34, 0x42, 0x86, 0x02, 0xd1,
+        0x19, 0x93, 0x13, 0x02, 0x81, 0x14, 0x42, 0x86, 0x03, 0xd1, 0x79, 0x30, 0x14, 0xd1, 0x79, 0x02,
+        0x68, 0x34, 0xbb, 0x14, 0x02, 0x69, 0x34, 0x95, 0x86, 0x02, 0xd1, 0x39, 0xbb, 0x14, 0x02, 0x69,
+        0x34, 0xeb, 0x13, 0x02, 0xd1, 0x39, 0x84, 0x13, 0x02, 0x69, 0x34, 0xbc, 0x14, 0x04, 0x69, 0x54,
+        0x64, 0x87, 0x8b, 0x14, 0x69, 0x54, 0x02, 0x26, 0x39, 0x40, 0x86, 0x02, 0xb4, 0x36, 0x40, 0x86,
+        0x02, 0x47, 0x16, 0x42, 0x86, 0x02, 0xdc, 0x39, 0x40, 0x86, 0x02, 0xca, 0x33, 0x40, 0x86, 0x02,
+        0xf9, 0x26, 0x40, 0x86, 0x02, 0x69, 0x34, 0x08, 0x87, 0x03, 0x69, 0x14, 0x69, 0x14, 0x66, 0x14,
+        0x03, 0xd1, 0x59, 0x1d, 0x19, 0xd1, 0x59, 0x02, 0xd4, 0x39, 0x40, 0x86, 0x02, 0xcf, 0x39, 0x40,
+        0x86, 0x02, 0x68, 0x34, 0xa4, 0x13, 0x02, 0xd1, 0x39, 0xa4, 0x13, 0x02, 0xd1, 0x19, 0xa8, 0x13,
+        0x02, 0xd7, 0x39, 0x42, 0x86, 0x03, 0x69, 0x34, 0xbc, 0x19, 0xa1, 0x87, 0x02, 0x68, 0x14, 0xb0,
+        0x19, 0x02, 0x3c, 0x39, 0x42, 0x86, 0x02, 0x68, 0x14, 0x73, 0x13, 0x04, 0x69, 0x14, 0x69, 0x14,
+        0x66, 0x14, 0x66, 0x14, 0x03, 0x68, 0x34, 0xaf, 0x19, 0xa1, 0x87, 0x02, 0x68, 0x34, 0x80, 0x16,
+        0x02, 0x73, 0x34, 0x42, 0x86, 0x02, 0xd1, 0x39, 0x80, 0x16, 0x02, 0x68, 0x34, 0xb0, 0x19, 0x02,
+        0x86, 0x34, 0x40, 0x86, 0x02, 0x38, 0x19, 0x42, 0x86, 0x02, 0x69, 0x34, 0xbb, 0x14, 0x02, 0xb5,
+        0x36, 0x42, 0x86, 0x02, 0xcd, 0x39, 0x40, 0x86, 0x02, 0x68, 0x34, 0x27, 0x15, 0x02, 0x68, 0x34,
+        0x95, 0x86, 0x03, 0x68, 0x14, 0x68, 0x14, 0x66, 0x14, 0x02, 0x71, 0x34, 0x40, 0x86, 0x02, 0xd1,
+        0x39, 0x27, 0x15, 0x02, 0x2e, 0x16, 0xa8, 0x14, 0x02, 0xc3, 0x33, 0x42, 0x86, 0x02, 0x69, 0x14,
+        0x66, 0x14, 0x02, 0x68, 0x34, 0x96, 0x86, 0x02, 0xd1, 0x39, 0x70, 0x1a, 0x03, 0x69, 0x14, 0x64,
+        0x87, 0x68, 0x14, 0x02, 0x69, 0x34, 0xa4, 0x13, 0x02, 0xb8, 0x39, 0x40, 0x86, 0x02, 0x68, 0x34,
+        0x3e, 0x13, 0x03, 0xd1, 0x19, 0xaf, 0x19, 0xa1, 0x87, 0x02, 0xd1, 0x39, 0x3e, 0x13, 0x02, 0x68,
+        0x34, 0xbd, 0x19, 0x02, 0xd1, 0x19, 0xbb, 0x14, 0x02, 0xd1, 0x19, 0x95, 0x86, 0x02, 0xdb, 0x39,
+        0x42, 0x86, 0x02, 0x38, 0x39, 0x40, 0x86, 0x02, 0x69, 0x34, 0x80, 0x16, 0x02, 0x69, 0x14, 0xeb,
+        0x13, 0x04, 0x68, 0x14, 0x69, 0x14, 0x67, 0x14, 0x67, 0x14, 0x02, 0x6f, 0x34, 0x40, 0x86, 0x02,
+        0x77, 0x34, 0x42, 0x86, 0x02, 0x46, 0x36, 0x40, 0x86, 0x02, 0x68, 0x34, 0x92, 0x16, 0x02, 0x4e,
+        0x36, 0x42, 0x86, 0x03, 0x69, 0x14, 0xbd, 0x19, 0xa1, 0x87, 0x02, 0xde, 0x19, 0x40, 0x86, 0x02,
+        0x69, 0x34, 0x27, 0x15, 0x03, 0xc3, 0x13, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x81, 0x14, 0x40, 0x86,
+        0x03, 0xd1, 0x39, 0xaf, 0x19, 0xa1, 0x87, 0x02, 0x68, 0x34, 0xbc, 0x19, 0x02, 0xd1, 0x19, 0x80,
+        0x16, 0x02, 0xd9, 0x39, 0x42, 0x86, 0x02, 0xd1, 0x39, 0xbc, 0x19, 0x02, 0xdc, 0x19, 0x42, 0x86,
+        0x02, 0x68, 0x34, 0x73, 0x13, 0x02, 0x69, 0x34, 0x3e, 0x13, 0x02, 0x47, 0x16, 0x40, 0x86, 0x02,
+        0xd1, 0x39, 0xbd, 0x19, 0x02, 0x3e, 0x39, 0x42, 0x86, 0x02, 0x69, 0x14, 0x95, 0x86, 0x02, 0x68,
+        0x14, 0x96, 0x86, 0x03, 0x69, 0x34, 0xbd, 0x19, 0xa1, 0x87, 0x02, 0xd7, 0x39, 0x40, 0x86, 0x02,
+        0x45, 0x16, 0x42, 0x86, 0x02, 0x68, 0x34, 0xed, 0x13, 0x03, 0x68, 0x34, 0xbc, 0x19, 0xa1, 0x87,
+        0x02, 0xd1, 0x39, 0xed, 0x13, 0x02, 0x3c, 0x39, 0x40, 0x86, 0x02, 0xd1, 0x19, 0x70, 0x1a, 0x02,
+        0xd1, 0x39, 0x92, 0x16, 0x02, 0x73, 0x34, 0x40, 0x86, 0x02, 0x38, 0x19, 0x40, 0x86, 0x02, 0xb5,
+        0x36, 0x40, 0x86, 0x02, 0x68, 0x34, 0xaf, 0x19, 0x02, 0xd1, 0x39, 0xaf, 0x19, 0x02, 0x69, 0x34,
+        0xbc, 0x19, 0x02, 0xb6, 0x16, 0x42, 0x86, 0x02, 0x26, 0x14, 0x25, 0x15, 0x02, 0xc3, 0x33, 0x40,
+        0x86, 0x02, 0xdd, 0x39, 0x42, 0x86, 0x02, 0xcb, 0x93, 0x42, 0x86, 0x02, 0xcb, 0x33, 0x42, 0x86,
+        0x02, 0x81, 0x34, 0x42, 0x86, 0x02, 0xce, 0x39, 0xa1, 0x87, 0x02, 0xdb, 0x39, 0x40, 0x86, 0x02,
+        0x68, 0x34, 0x08, 0x87, 0x02, 0xd1, 0x19, 0xb0, 0x19, 0x02, 0x77, 0x34, 0x40, 0x86, 0x02, 0x4e,
+        0x36, 0x40, 0x86, 0x02, 0xce, 0x39, 0x42, 0x86, 0x02, 0x4e, 0x16, 0x42, 0x86, 0x02, 0xd9, 0x39,
+        0x40, 0x86, 0x02, 0xdc, 0x19, 0x40, 0x86, 0x02, 0x3e, 0x39, 0x40, 0x86, 0x02, 0xb9, 0x39, 0x42,
+        0x86, 0x02, 0xda, 0x19, 0x42, 0x86, 0x02, 0x42, 0x16, 0x94, 0x81, 0x02, 0x45, 0x16, 0x40, 0x86,
+        0x02, 0x69, 0x14, 0xbd, 0x19, 0x02, 0x70, 0x34, 0x42, 0x86, 0x02, 0xce, 0x19, 0xa1, 0x87, 0x02,
+        0xc3, 0x13, 0x42, 0x86, 0x02, 0x68, 0x14, 0x08, 0x87, 0x02, 0xd1, 0x19, 0x7c, 0x13, 0x02, 0x68,
+        0x14, 0x92, 0x16, 0x02, 0xb6, 0x16, 0x40, 0x86, 0x02, 0x37, 0x39, 0x42, 0x86, 0x03, 0xce, 0x19,
+        0x42, 0x86, 0xa1, 0x87, 0x03, 0x68, 0x14, 0x67, 0x14, 0x67, 0x14, 0x02, 0xdd, 0x39, 0x40, 0x86,
+        0x02, 0xcf, 0x19, 0x42, 0x86, 0x02, 0xd1, 0x19, 0x2c, 0x15, 0x02, 0x4b, 0x13, 0xe9, 0x17, 0x02,
+        0x68, 0x14, 0x67, 0x14, 0x02, 0xcb, 0x93, 0x40, 0x86, 0x02, 0x6e, 0x34, 0x42, 0x86, 0x02, 0xcb,
+        0x33, 0x40, 0x86, 0x02, 0x81, 0x34, 0x40, 0x86, 0x02, 0xb6, 0x36, 0xa1, 0x87, 0x02, 0x45, 0x36,
+        0x42, 0x86, 0x02, 0xb4, 0x16, 0x42, 0x86, 0x02, 0x69, 0x14, 0x73, 0x13, 0x04, 0x69, 0x14, 0x69,
+        0x14, 0x67, 0x14, 0x66, 0x14, 0x02, 0x35, 0x39, 0x42, 0x86, 0x02, 0x68, 0x14, 0x93, 0x13, 0x02,
+        0xb6, 0x36, 0x42, 0x86, 0x03, 0x68, 0x14, 0x69, 0x14, 0x66, 0x14, 0x02, 0xce, 0x39, 0x40, 0x86,
+        0x02, 0x4e, 0x16, 0x40, 0x86, 0x02, 0x87, 0x34, 0x42, 0x86, 0x02, 0x86, 0x14, 0x42, 0x86, 0x02,
+        0xd6, 0x39, 0x42, 0x86, 0x02, 0xc4, 0x33, 0x42, 0x86, 0x02, 0x69, 0x34, 0x96, 0x86, 0x02, 0xb9,
+        0x39, 0x40, 0x86, 0x02, 0x68, 0x14, 0xa8, 0x13, 0x02, 0xd1, 0x19, 0x84, 0x13, 0x02, 0xda, 0x19,
+        0x40, 0x86, 0x02, 0xd8, 0x19, 0x42, 0x86, 0x02, 0xc3, 0x13, 0x40, 0x86, 0x02, 0xb9, 0x19, 0x42,
+        0x86, 0x02, 0x3d, 0x19, 0x42, 0x86, 0x02, 0xcf, 0x19, 0x40, 0x86, 0x04, 0x68, 0x14, 0x68, 0x14,
+        0x67, 0x14, 0x67, 0x14, 0x03, 0xd1, 0x19, 0xd1, 0x19, 0xd2, 0x19, 0x02, 0x68, 0x14, 0xbb, 0x14,
+        0x02, 0x3b, 0x14, 0x44, 0x87, 0x02, 0xd1, 0x19, 0x27, 0x15, 0x02, 0xb4, 0x16, 0x40, 0x86, 0x02,
+        0xcd, 0x19, 0x42, 0x86, 0x02, 0xd3, 0x86, 0xa5, 0x14, 0x02, 0x70, 0x14, 0x42, 0x86, 0x03, 0xb6,
+        0x16, 0x42, 0x86, 0xa1, 0x87, 0x04, 0x69, 0x14, 0x64, 0x87, 0x8b, 0x14, 0x69, 0x14, 0x02, 0x36,
+        0x16, 0x2b, 0x93, 0x02, 0x68, 0x14, 0x80, 0x16, 0x02, 0x86, 0x14, 0x40, 0x86, 0x02, 0x08, 0x14,
+        0x1b, 0x0b, 0x02, 0xd1, 0x19, 0xbc, 0x19, 0x02, 0xca, 0x13, 0x42, 0x86, 0x02, 0x41, 0x94, 0xe8,
+        0x95, 0x02, 0xd8, 0x19, 0x40, 0x86, 0x02, 0xb9, 0x19, 0x40, 0x86, 0x02, 0xd1, 0x19, 0xed, 0x13,
+        0x02, 0xf9, 0x86, 0x42, 0x86, 0x03, 0xd1, 0x19, 0xbd, 0x19, 0xa1, 0x87, 0x02, 0x3d, 0x19, 0x40,
+        0x86, 0x02, 0xd6, 0x19, 0x42, 0x86, 0x03, 0x69, 0x14, 0x66, 0x14, 0x66, 0x14, 0x02, 0xd1, 0x19,
+        0xaf, 0x19, 0x03, 0x69, 0x14, 0x69, 0x14, 0x67, 0x14, 0x02, 0xcd, 0x19, 0x40, 0x86, 0x02, 0x70,
+        0x14, 0x40, 0x86, 0x03, 0x68, 0x14, 0xbc, 0x19, 0xa1, 0x87, 0x02, 0x6e, 0x14, 0x42, 0x86, 0x02,
+        0x69, 0x14, 0x92, 0x16, 0x03, 0x68, 0x14, 0x68, 0x14, 0x67, 0x14, 0x02, 0x69, 0x14, 0x67, 0x14,
+        0x02, 0x75, 0x95, 0x42, 0x86, 0x03, 0x69, 0x14, 0x64, 0x87, 0x69, 0x14, 0x02, 0xd1, 0x19, 0xbc,
+        0x14, 0x02, 0xdf, 0x19, 0x42, 0x86, 0x02, 0xca, 0x13, 0x40, 0x86, 0x02, 0x82, 0x14, 0x42, 0x86,
+        0x02, 0x69, 0x14, 0x93, 0x13, 0x02, 0x68, 0x14, 0x7c, 0x13, 0x02, 0xf9, 0x86, 0x40, 0x86, 0x02,
+        0xd6, 0x19, 0x40, 0x86, 0x02, 0x68, 0x14, 0x2c, 0x15, 0x02, 0x69, 0x14, 0xa8, 0x13, 0x02, 0xd4,
+        0x19, 0x42, 0x86, 0x04, 0x68, 0x14, 0x69, 0x14, 0x66, 0x14, 0x66, 0x14, 0x02, 0x77, 0x14, 0x42,
+        0x86, 0x02, 0x39, 0x19, 0x42, 0x86, 0x02, 0xd1, 0x19, 0xa4, 0x13, 0x02, 0x6e, 0x14, 0x40, 0x86,
+        0x03, 0xd1, 0x19, 0xd2, 0x19, 0xd2, 0x19, 0x02, 0x69, 0x14, 0xbb, 0x14, 0x02, 0xd1, 0x19, 0x96,
+        0x86, 0x02, 0x75, 0x95, 0x40, 0x86, 0x04, 0x68, 0x14, 0x64, 0x87, 0x8b, 0x14, 0x68, 0x14, 0x02,
+        0xd1, 0x19, 0x3e, 0x13, 0x02, 0xdf, 0x19, 0x40, 0x86, 0x02, 0x82, 0x14, 0x40, 0x86, 0x02, 0x44,
+        0x13, 0xeb, 0x17, 0x02, 0xdd, 0x19, 0x42, 0x86, 0x03, 0x68, 0x14, 0xaf, 0x19, 0xa1, 0x87, 0x02,
+        0x69, 0x14, 0x80, 0x16, 0x02, 0xa3, 0x16, 0x42, 0x86, 0x02, 0x69, 0x14, 0x96, 0x86, 0x02, 0x46,
+        0x16, 0x42, 0x86, 0x02, 0xb6, 0x16, 0xa1, 0x87, 0x02, 0x68, 0x14, 0x27, 0x15, 0x02, 0x26, 0x14,
+        0x1b, 0x0b, 0x02, 0xd4, 0x19, 0x40, 0x86, 0x02, 0x77, 0x14, 0x40, 0x86, 0x02, 0x39, 0x19, 0x40,
+        0x86, 0x02, 0x37, 0x19, 0x42, 0x86, 0x03, 0x69, 0x14, 0x67, 0x14, 0x66, 0x14, 0x03, 0xc3, 0x13,
+        0x42, 0x86, 0xa1, 0x87, 0x02, 0x68, 0x14, 0xbc, 0x19, 0x02, 0xd1, 0x19, 0xeb, 0x13, 0x04, 0x69,
+        0x14, 0x69, 0x14, 0x67, 0x14, 0x67, 0x14, 0x02, 0xd1, 0x19, 0x08, 0x87, 0x02, 0x68, 0x14, 0xed,
+        0x13, 0x03, 0x69, 0x14, 0xbc, 0x19, 0xa1, 0x87, 0x02, 0xdd, 0x19, 0x40, 0x86, 0x02, 0xc3, 0x13,
+        0xa1, 0x87, 0x03, 0x68, 0x14, 0x66, 0x14, 0x66, 0x14, 0x03, 0x68, 0x14, 0x69, 0x14, 0x67, 0x14,
+        0x02, 0xa3, 0x16, 0x40, 0x86, 0x02, 0xdb, 0x19, 0x42, 0x86, 0x02, 0x68, 0x14, 0xaf, 0x19, 0x02,
+        0x46, 0x16, 0x40, 0x86, 0x02, 0x35, 0x16, 0xab, 0x14, 0x02, 0x68, 0x14, 0x95, 0x86, 0x02, 0x42,
+        0x16, 0x95, 0x81, 0x02, 0xc4, 0x13, 0x42, 0x86, 0x02, 0x15, 0x14, 0xba, 0x19, 0x03, 0xd1, 0x19,
+        0x1d, 0x19, 0xd1, 0x19, 0x02, 0x69, 0x14, 0x08, 0x87, 0x02, 0x69, 0x14, 0x7c, 0x13, 0x02, 0x37,
+        0x19, 0x40, 0x86, 0x02, 0x73, 0x14, 0x42, 0x86, 0x02, 0x69, 0x14, 0x2c, 0x15, 0x02, 0xb5, 0x16,
+        0x42, 0x86, 0x02, 0x35, 0x19, 0x42, 0x86, 0x04, 0x68, 0x14, 0x69, 0x14, 0x67, 0x14, 0x66, 0x14,
+        0x02, 0x64, 0x87, 0x25, 0x15, 0x02, 0x64, 0x87, 0x79, 0x1a, 0x02, 0x68, 0x14, 0xbc, 0x14, 0x03,
+        0xce, 0x19, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x87, 0x14, 0x42, 0x86, 0x02, 0x4d, 0x16, 0x42, 0x86,
+        0x04, 0x68, 0x14, 0x68, 0x14, 0x66, 0x14, 0x66, 0x14, 0x02, 0xdb, 0x19, 0x40, 0x86, 0x02, 0xd9,
+        0x19, 0x42, 0x86, 0x02, 0xc4, 0x13, 0x40, 0x86, 0x02, 0xd1, 0x19, 0xbd, 0x19, 0x02, 0x68, 0x14,
+        0xa4, 0x13, 0x02, 0x3e, 0x19, 0x42, 0x86, 0x02, 0xf3, 0x93, 0xa7, 0x86, 0x03, 0x69, 0x14, 0xaf,
+        0x19, 0xa1, 0x87, 0x02, 0xf3, 0x93, 0x08, 0x13, 0x02, 0xd1, 0x19, 0xd2, 0x19, 0x02, 0x73, 0x14,
+        0x40, 0x86, 0x02, 0xb5, 0x16, 0x40, 0x86, 0x02, 0x35, 0x19, 0x40, 0x86, 0x02, 0x69, 0x14, 0x27,
+        0x15, 0x02, 0xce, 0x19, 0x42, 0x86, 0x02, 0x71, 0x14, 0x42, 0x86, 0x02, 0xd1, 0x19, 0x73, 0x13,
+        0x02, 0x68, 0x14, 0x3e, 0x13, 0x02, 0xf4, 0x13, 0x20, 0x86, 0x02, 0x87, 0x14, 0x40, 0x86, 0x03,
+        0xb6, 0x16, 0x40, 0x86, 0xa1, 0x87, 0x02, 0x4d, 0x16, 0x40, 0x86, 0x02, 0x69, 0x14, 0xbc, 0x19,
+        0x02, 0x4b, 0x16, 0x42, 0x86, 0x02, 0xd9, 0x19, 0x40, 0x86, 0x02, 0x3e, 0x19, 0x40, 0x86, 0x02,
+        0x69, 0x14, 0xed, 0x13, 0x02, 0xd7, 0x19, 0x42, 0x86, 0x02, 0xb8, 0x19, 0x42, 0x86, 0x03, 0x68,
+        0x14, 0x67, 0x14, 0x66, 0x14, 0x02, 0x3c, 0x19, 0x42, 0x86, 0x02, 0x68, 0x14, 0x66, 0x14, 0x03,
+        0x68, 0x14, 0x64, 0x87, 0x68, 0x14, 0x02, 0x69, 0x14, 0xaf, 0x19, 0x02, 0xce, 0x19, 0x40, 0x86,
+        0x02, 0x71, 0x14, 0x40, 0x86, 0x02, 0x68, 0x14, 0xeb, 0x13, 0x03, 0x68, 0x14, 0xbd, 0x19, 0xa1,
+        0x87, 0x02, 0x6f, 0x14, 0x42, 0x86, 0x04, 0xd1, 0x19, 0xd1, 0x19, 0xd2, 0x19, 0xd2, 0x19, 0x02,
+        0x69, 0x14, 0xbc, 0x14, 0x02, 0xcc, 0x93, 0x42, 0x86, 0x02, 0x4b, 0x16, 0x40, 0x86, 0x02, 0x26,
+        0x19, 0x42, 0x86, 0x02, 0xd7, 0x19, 0x40, 0x86,
+    };
+    internal static ReadOnlySpan<byte> RgiEmojiTagSequence => new byte[]
+    {
+        0x67, 0x62, 0x65, 0x6e, 0x67, 0x00, 0x67, 0x62, 0x73, 0x63, 0x74, 0x00, 0x67, 0x62, 0x77, 0x6c,
+        0x73, 0x00,
+    };
+
+    // ---- Binary property tables ----
+    // [0] unicode_prop_Hyphen_table (28 bytes)
+    internal static ReadOnlySpan<byte> PropHyphenTable => new byte[]
+    {
+        0xac, 0x80, 0xfe, 0x80, 0x44, 0xdb, 0x80, 0x52, 0x7a, 0x80, 0x48, 0x08, 0x81, 0x4e, 0x04, 0x80,
+        0x42, 0xe2, 0x80, 0x60, 0xcd, 0x66, 0x80, 0x40, 0xa8, 0x80, 0xd6, 0x80,
+    };
+    // [1] unicode_prop_Other_Math_table (200 bytes)
+    internal static ReadOnlySpan<byte> PropOther_MathTable => new byte[]
+    {
+        0xdd, 0x80, 0x43, 0x70, 0x11, 0x80, 0x99, 0x09, 0x81, 0x5c, 0x1f, 0x80, 0x9a, 0x82, 0x8a, 0x80,
+        0x9f, 0x83, 0x97, 0x81, 0x8d, 0x81, 0xc0, 0x8c, 0x18, 0x11, 0x1c, 0x91, 0x03, 0x01, 0x89, 0x00,
+        0x14, 0x28, 0x11, 0x09, 0x02, 0x05, 0x13, 0x24, 0xca, 0x21, 0x18, 0x08, 0x08, 0x00, 0x21, 0x0b,
+        0x0b, 0x91, 0x09, 0x00, 0x06, 0x00, 0x29, 0x41, 0x21, 0x83, 0x40, 0xa7, 0x08, 0x80, 0x97, 0x80,
+        0x90, 0x80, 0x41, 0xbc, 0x81, 0x8b, 0x88, 0x24, 0x21, 0x09, 0x14, 0x8d, 0x00, 0x01, 0x85, 0x97,
+        0x81, 0xb8, 0x00, 0x80, 0x9c, 0x83, 0x88, 0x81, 0x41, 0x55, 0x81, 0x9e, 0x89, 0x41, 0x92, 0x95,
+        0xbe, 0x83, 0x9f, 0x81, 0x60, 0xd4, 0x62, 0x00, 0x03, 0x80, 0x40, 0xd2, 0x00, 0x80, 0x60, 0xd4,
+        0xc0, 0xd4, 0x80, 0xc6, 0x01, 0x08, 0x09, 0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0, 0x03, 0x0f,
+        0x06, 0x80, 0x9b, 0x03, 0x04, 0x00, 0x16, 0x80, 0x41, 0x53, 0x81, 0x98, 0x80, 0x98, 0x80, 0x9e,
+        0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x07, 0x81,
+        0xb1, 0x55, 0xff, 0x18, 0x9a, 0x01, 0x00, 0x08, 0x80, 0x89, 0x03, 0x00, 0x00, 0x28, 0x18, 0x00,
+        0x00, 0x02, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x06, 0x03, 0x03, 0x00,
+        0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90,
+    };
+    // [2] unicode_prop_Other_Alphabetic_table (452 bytes)
+    internal static ReadOnlySpan<byte> PropOther_AlphabeticTable => new byte[]
+    {
+        0x43, 0x44, 0x80, 0x9c, 0x8c, 0x42, 0x3f, 0x8d, 0x00, 0x01, 0x01, 0x00, 0xc7, 0x8a, 0xaf, 0x8c,
+        0x06, 0x8f, 0x80, 0xe4, 0x33, 0x19, 0x0b, 0x80, 0xa2, 0x80, 0x9d, 0x8f, 0xe5, 0x8a, 0xe4, 0x0a,
+        0x88, 0x02, 0x03, 0xe9, 0x80, 0xbb, 0x8b, 0x16, 0x85, 0x93, 0xb5, 0x09, 0x8e, 0x01, 0x22, 0x89,
+        0x81, 0x9c, 0x82, 0xb9, 0x31, 0x09, 0x81, 0x89, 0x80, 0x89, 0x81, 0x9c, 0x82, 0xb9, 0x23, 0x09,
+        0x0b, 0x80, 0x9d, 0x0a, 0x80, 0x8a, 0x82, 0xb9, 0x38, 0x10, 0x81, 0x94, 0x81, 0x95, 0x13, 0x82,
+        0xb9, 0x31, 0x09, 0x81, 0x88, 0x81, 0x89, 0x81, 0x9d, 0x80, 0xba, 0x22, 0x10, 0x82, 0x89, 0x80,
+        0xa7, 0x84, 0xb8, 0x30, 0x10, 0x17, 0x81, 0x8a, 0x81, 0x9c, 0x82, 0xb9, 0x30, 0x10, 0x17, 0x81,
+        0x8a, 0x81, 0x8e, 0x80, 0x8b, 0x83, 0xb9, 0x30, 0x10, 0x82, 0x89, 0x80, 0x89, 0x81, 0x9c, 0x82,
+        0xca, 0x28, 0x00, 0x87, 0x91, 0x81, 0xbc, 0x01, 0x86, 0x91, 0x80, 0xe2, 0x01, 0x28, 0x81, 0x8f,
+        0x80, 0x40, 0xa2, 0x92, 0x88, 0x8a, 0x80, 0xa3, 0xed, 0x8b, 0x00, 0x0b, 0x96, 0x1b, 0x10, 0x11,
+        0x32, 0x83, 0x8c, 0x8b, 0x00, 0x89, 0x83, 0x46, 0x73, 0x81, 0x9d, 0x81, 0x9d, 0x81, 0x9d, 0x81,
+        0xc1, 0x92, 0x40, 0xbb, 0x81, 0xa1, 0x80, 0xf5, 0x8b, 0x83, 0x88, 0x40, 0xdd, 0x84, 0xb8, 0x89,
+        0x81, 0x93, 0xc9, 0x81, 0x8a, 0x82, 0xb0, 0x84, 0xaf, 0x8e, 0xbb, 0x82, 0x9d, 0x88, 0x09, 0xb8,
+        0x8a, 0xb1, 0x92, 0x41, 0x9b, 0xa1, 0x46, 0xc0, 0xb3, 0x48, 0xf5, 0x9f, 0x60, 0x78, 0x73, 0x87,
+        0xa1, 0x81, 0x41, 0x61, 0x07, 0x80, 0x96, 0x84, 0xd7, 0x81, 0xb1, 0x8f, 0x00, 0xb8, 0x80, 0xa5,
+        0x84, 0x9b, 0x8b, 0xac, 0x83, 0xaf, 0x8b, 0xa4, 0x80, 0xc2, 0x8d, 0x8b, 0x07, 0x81, 0xac, 0x82,
+        0xb1, 0x00, 0x11, 0x0c, 0x80, 0xab, 0x24, 0x80, 0x40, 0xec, 0x87, 0x60, 0x4f, 0x32, 0x80, 0x48,
+        0x56, 0x84, 0x46, 0x85, 0x10, 0x0c, 0x83, 0x43, 0x13, 0x83, 0xc0, 0x80, 0x41, 0x40, 0x81, 0xcc,
+        0x82, 0x41, 0x02, 0x82, 0xb4, 0x8d, 0xac, 0x81, 0x8a, 0x82, 0xac, 0x88, 0x88, 0x80, 0xbc, 0x82,
+        0xa3, 0x8b, 0x91, 0x81, 0xb8, 0x82, 0xaf, 0x8c, 0x8d, 0x81, 0xdb, 0x88, 0x08, 0x28, 0x08, 0x40,
+        0x9c, 0x89, 0x96, 0x83, 0xb9, 0x31, 0x09, 0x81, 0x89, 0x80, 0x89, 0x81, 0xd3, 0x88, 0x00, 0x08,
+        0x03, 0x01, 0xe6, 0x8c, 0x02, 0xe9, 0x91, 0x40, 0xec, 0x31, 0x86, 0x9c, 0x81, 0xd1, 0x8e, 0x00,
+        0xe9, 0x8a, 0xe6, 0x8d, 0x41, 0x00, 0x8c, 0x40, 0xf6, 0x28, 0x09, 0x0a, 0x00, 0x80, 0x40, 0x8d,
+        0x31, 0x2b, 0x80, 0x9b, 0x89, 0xa9, 0x20, 0x83, 0x91, 0x8a, 0xad, 0x8d, 0x40, 0xc7, 0x87, 0x40,
+        0xc6, 0x38, 0x86, 0xd2, 0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00, 0x08, 0x10, 0x02, 0x80, 0xc1, 0x20,
+        0x08, 0x83, 0x41, 0x5b, 0x83, 0x88, 0x08, 0x80, 0xaf, 0x32, 0x82, 0x60, 0x41, 0xdc, 0x90, 0x4e,
+        0x1f, 0x00, 0xb6, 0x33, 0xdc, 0x81, 0x60, 0x4c, 0xab, 0x80, 0x60, 0x23, 0x60, 0x30, 0x90, 0x0e,
+        0x01, 0x04, 0xe3, 0x80, 0x46, 0x52, 0x01, 0x06, 0x0c, 0x80, 0x42, 0x50, 0x80, 0x47, 0xe7, 0x99,
+        0x85, 0x99, 0x85, 0x99,
+    };
+    // [3] unicode_prop_Other_Lowercase_table (68 bytes)
+    internal static ReadOnlySpan<byte> PropOther_LowercaseTable => new byte[]
+    {
+        0x40, 0xa9, 0x80, 0x8e, 0x80, 0x41, 0xf4, 0x88, 0x31, 0x9d, 0x84, 0xdf, 0x80, 0xb3, 0x80, 0x4d,
+        0x80, 0x80, 0x4c, 0x2e, 0xbe, 0x8c, 0x80, 0xa1, 0xa4, 0x42, 0xb0, 0x80, 0x8c, 0x80, 0x8f, 0x8c,
+        0x40, 0xd2, 0x8f, 0x43, 0x4f, 0x99, 0x47, 0x91, 0x81, 0x60, 0x7a, 0x1d, 0x81, 0x40, 0xd1, 0x80,
+        0xff, 0x1a, 0x81, 0x43, 0x61, 0x83, 0x88, 0x80, 0x60, 0x5c, 0x15, 0x01, 0x10, 0xa9, 0x80, 0x88,
+        0x60, 0xd8, 0x74, 0xbd,
+    };
+    // [4] unicode_prop_Other_Uppercase_table (15 bytes)
+    internal static ReadOnlySpan<byte> PropOther_UppercaseTable => new byte[]
+    {
+        0x60, 0x21, 0x5f, 0x8f, 0x43, 0x45, 0x99, 0x61, 0xcc, 0x5f, 0x99, 0x85, 0x99, 0x85, 0x99,
+    };
+    // [5] unicode_prop_Other_Grapheme_Extend_table (112 bytes)
+    internal static ReadOnlySpan<byte> PropOther_Grapheme_ExtendTable => new byte[]
+    {
+        0x49, 0xbd, 0x80, 0x97, 0x80, 0x41, 0x65, 0x80, 0x97, 0x80, 0xe5, 0x80, 0x97, 0x80, 0x40, 0xe7,
+        0x00, 0x03, 0x08, 0x81, 0x88, 0x81, 0xe6, 0x80, 0x97, 0x80, 0xf6, 0x80, 0x8e, 0x80, 0x49, 0x34,
+        0x80, 0x9d, 0x80, 0x43, 0xff, 0x04, 0x00, 0x04, 0x81, 0xe4, 0x80, 0xc6, 0x81, 0x44, 0x17, 0x80,
+        0x50, 0x20, 0x81, 0x60, 0x79, 0x22, 0x80, 0xeb, 0x80, 0x60, 0x55, 0xdc, 0x81, 0x52, 0x1f, 0x80,
+        0xf3, 0x80, 0x41, 0x07, 0x80, 0x8d, 0x80, 0x88, 0x80, 0xdf, 0x80, 0x88, 0x01, 0x00, 0x14, 0x80,
+        0x40, 0xdf, 0x80, 0x8b, 0x80, 0x40, 0xf0, 0x80, 0x41, 0x05, 0x80, 0x42, 0x78, 0x80, 0x8b, 0x80,
+        0x46, 0x02, 0x80, 0x60, 0x50, 0xad, 0x81, 0x60, 0x61, 0x72, 0x0d, 0x85, 0x6c, 0x2e, 0xac, 0xdf,
+    };
+    // [6] unicode_prop_Other_Default_Ignorable_Code_Point_table (32 bytes)
+    internal static ReadOnlySpan<byte> PropOther_Default_Ignorable_Code_PointTable => new byte[]
+    {
+        0x43, 0x4e, 0x80, 0x4e, 0x0e, 0x81, 0x46, 0x52, 0x81, 0x48, 0xae, 0x80, 0x50, 0xfd, 0x80, 0x60,
+        0xce, 0x3a, 0x80, 0xce, 0x88, 0x6d, 0x00, 0x06, 0x00, 0x9d, 0xdf, 0xff, 0x40, 0xef, 0x4e, 0x0f,
+    };
+    // [7] unicode_prop_Other_ID_Start_table (11 bytes)
+    internal static ReadOnlySpan<byte> PropOther_ID_StartTable => new byte[]
+    {
+        0x58, 0x84, 0x81, 0x48, 0x90, 0x80, 0x94, 0x80, 0x4f, 0x6b, 0x81,
+    };
+    // [8] unicode_prop_Other_ID_Continue_table (22 bytes)
+    internal static ReadOnlySpan<byte> PropOther_ID_ContinueTable => new byte[]
+    {
+        0x40, 0xb6, 0x80, 0x42, 0xce, 0x80, 0x4f, 0xe0, 0x88, 0x46, 0x67, 0x80, 0x46, 0x30, 0x81, 0x50,
+        0xec, 0x80, 0x60, 0xce, 0x68, 0x80,
+    };
+    // [9] unicode_prop_Prepended_Concatenation_Mark_table (19 bytes)
+    internal static ReadOnlySpan<byte> PropPrepended_Concatenation_MarkTable => new byte[]
+    {
+        0x45, 0xff, 0x85, 0x40, 0xd6, 0x80, 0xb0, 0x80, 0x41, 0x7f, 0x81, 0xcf, 0x80, 0x61, 0x07, 0xd9,
+        0x80, 0x8e, 0x80,
+    };
+    // [10] unicode_prop_ID_Continue1_table (708 bytes)
+    internal static ReadOnlySpan<byte> PropID_Continue1Table => new byte[]
+    {
+        0xaf, 0x89, 0xa4, 0x80, 0xd6, 0x80, 0x42, 0x47, 0xef, 0x96, 0x80, 0x40, 0xfa, 0x84, 0x41, 0x08,
+        0xac, 0x00, 0x01, 0x01, 0x00, 0xc7, 0x8a, 0xaf, 0x9e, 0x28, 0xe4, 0x31, 0x29, 0x08, 0x19, 0x89,
+        0x96, 0x80, 0x9d, 0x9a, 0xda, 0x8a, 0x8e, 0x89, 0xa0, 0x88, 0x88, 0x80, 0x97, 0x18, 0x88, 0x02,
+        0x04, 0xaa, 0x82, 0xba, 0x88, 0xa9, 0x97, 0x80, 0xa0, 0xb5, 0x10, 0x91, 0x06, 0x89, 0x09, 0x89,
+        0x90, 0x82, 0xb7, 0x00, 0x31, 0x09, 0x82, 0x88, 0x80, 0x89, 0x09, 0x89, 0x8d, 0x01, 0x82, 0xb7,
+        0x00, 0x23, 0x09, 0x12, 0x80, 0x93, 0x8b, 0x10, 0x8a, 0x82, 0xb7, 0x00, 0x38, 0x10, 0x82, 0x93,
+        0x09, 0x89, 0x89, 0x28, 0x82, 0xb7, 0x00, 0x31, 0x09, 0x16, 0x82, 0x89, 0x09, 0x89, 0x91, 0x80,
+        0xba, 0x22, 0x10, 0x83, 0x88, 0x80, 0x8d, 0x89, 0x8f, 0x84, 0xb6, 0x00, 0x30, 0x10, 0x1e, 0x81,
+        0x8a, 0x09, 0x89, 0x90, 0x82, 0xb7, 0x00, 0x30, 0x10, 0x1e, 0x81, 0x8a, 0x09, 0x89, 0x10, 0x8b,
+        0x83, 0xb6, 0x08, 0x30, 0x10, 0x83, 0x88, 0x80, 0x89, 0x09, 0x89, 0x90, 0x82, 0xc5, 0x03, 0x28,
+        0x00, 0x3d, 0x89, 0x09, 0xbc, 0x01, 0x86, 0x8b, 0x38, 0x89, 0xd6, 0x01, 0x88, 0x8a, 0x30, 0x89,
+        0xbd, 0x0d, 0x89, 0x8a, 0x00, 0x00, 0x03, 0x81, 0xb0, 0x93, 0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88,
+        0x80, 0xe3, 0x93, 0x80, 0x89, 0x8b, 0x1b, 0x10, 0x11, 0x32, 0x83, 0x8c, 0x8b, 0x80, 0x8e, 0x42,
+        0xbe, 0x82, 0x88, 0x88, 0x43, 0x9f, 0x83, 0x9b, 0x82, 0x9c, 0x81, 0x9d, 0x81, 0xbf, 0x9f, 0x88,
+        0x01, 0x89, 0xa0, 0x10, 0x8a, 0x40, 0x8e, 0x80, 0xf5, 0x8b, 0x83, 0x8b, 0x89, 0x89, 0xff, 0x8a,
+        0xbb, 0x84, 0xb8, 0x89, 0x80, 0x9c, 0x81, 0x8a, 0x85, 0x89, 0x95, 0x8d, 0x80, 0x9e, 0x81, 0x8b,
+        0x93, 0x84, 0xae, 0x90, 0x8a, 0x89, 0x90, 0x88, 0x8b, 0x82, 0x9d, 0x8c, 0x81, 0x89, 0xab, 0x8d,
+        0xaf, 0x93, 0x87, 0x89, 0x85, 0x89, 0xf5, 0x10, 0x94, 0x18, 0x28, 0x0a, 0x40, 0xc5, 0xbf, 0x42,
+        0x0b, 0x81, 0xb0, 0x81, 0x92, 0x80, 0xfa, 0x8c, 0x18, 0x82, 0x8b, 0x4b, 0xfd, 0x82, 0x40, 0x8c,
+        0x80, 0xdf, 0x9f, 0x42, 0x29, 0x85, 0xe8, 0x81, 0xdf, 0x80, 0x60, 0x75, 0x23, 0x89, 0xc4, 0x03,
+        0x89, 0x9f, 0x81, 0xcf, 0x81, 0x41, 0x0f, 0x02, 0x03, 0x80, 0x96, 0x23, 0x80, 0xd2, 0x81, 0xb1,
+        0x91, 0x89, 0x89, 0x85, 0x91, 0x8c, 0x8a, 0x9b, 0x87, 0x98, 0x8c, 0xab, 0x83, 0xae, 0x8d, 0x8e,
+        0x89, 0x8a, 0x80, 0x89, 0x89, 0xae, 0x8d, 0x8b, 0x07, 0x09, 0x89, 0xa0, 0x82, 0xb1, 0x00, 0x11,
+        0x0c, 0x08, 0x80, 0xa8, 0x24, 0x81, 0x40, 0xeb, 0x38, 0x09, 0x89, 0x60, 0x4f, 0x23, 0x80, 0x42,
+        0xe0, 0x8f, 0x8f, 0x8f, 0x11, 0x97, 0x82, 0x40, 0xbf, 0x89, 0xa4, 0x80, 0xa4, 0x80, 0x42, 0x96,
+        0x80, 0x40, 0xe1, 0x80, 0x40, 0x94, 0x84, 0x41, 0x24, 0x89, 0x45, 0x56, 0x10, 0x0c, 0x83, 0xa7,
+        0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3c, 0x1f, 0x89, 0x85, 0x89, 0x9e, 0x84, 0x41, 0x3c, 0x81,
+        0xcc, 0x85, 0xc5, 0x8a, 0xb0, 0x83, 0xf9, 0x82, 0xb4, 0x8e, 0x9e, 0x8a, 0x09, 0x89, 0x83, 0xac,
+        0x8a, 0x30, 0xac, 0x89, 0x2a, 0xa3, 0x8d, 0x80, 0x89, 0x21, 0xab, 0x80, 0x8b, 0x82, 0xaf, 0x8d,
+        0x3b, 0x80, 0x8b, 0xd1, 0x8b, 0x28, 0x08, 0x40, 0x9c, 0x8b, 0x84, 0x89, 0x2b, 0xb6, 0x08, 0x31,
+        0x09, 0x82, 0x88, 0x80, 0x89, 0x09, 0x32, 0x84, 0xc2, 0x88, 0x00, 0x08, 0x03, 0x04, 0x00, 0x8d,
+        0x81, 0xd1, 0x91, 0x88, 0x89, 0x18, 0xd0, 0x93, 0x8b, 0x89, 0x40, 0xd4, 0x31, 0x88, 0x9a, 0x81,
+        0xd1, 0x90, 0x8e, 0x89, 0xd0, 0x8c, 0x87, 0x89, 0x85, 0x93, 0xb8, 0x8e, 0x83, 0x89, 0x40, 0xf1,
+        0x8e, 0x40, 0xa4, 0x89, 0xc5, 0x28, 0x09, 0x18, 0x00, 0x81, 0x8b, 0x89, 0xf6, 0x31, 0x32, 0x80,
+        0x9b, 0x89, 0xa7, 0x30, 0x1f, 0x80, 0x88, 0x8a, 0xad, 0x8f, 0x40, 0xc5, 0x87, 0x40, 0x87, 0x89,
+        0xb4, 0x38, 0x87, 0x8f, 0x89, 0xb7, 0x95, 0x80, 0x8d, 0xf9, 0x2a, 0x00, 0x08, 0x30, 0x07, 0x89,
+        0xaf, 0x20, 0x08, 0x27, 0x89, 0xb5, 0x89, 0x41, 0x08, 0x83, 0x88, 0x08, 0x80, 0xaf, 0x32, 0x84,
+        0x8c, 0x8a, 0x54, 0xe4, 0x05, 0x8e, 0x60, 0x2c, 0xc7, 0x9b, 0x49, 0x25, 0x89, 0xd5, 0x89, 0xa5,
+        0x84, 0xba, 0x86, 0x98, 0x89, 0x42, 0x15, 0x89, 0x41, 0xd4, 0x00, 0xb6, 0x33, 0xd0, 0x80, 0x8a,
+        0x81, 0x60, 0x4c, 0xaa, 0x81, 0x50, 0x50, 0x89, 0x42, 0x05, 0xad, 0x81, 0x96, 0x42, 0x1d, 0x22,
+        0x2f, 0x39, 0x86, 0x9d, 0x83, 0x40, 0x93, 0x82, 0x45, 0x88, 0xb1, 0x41, 0xff, 0xb6, 0x83, 0xb1,
+        0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45, 0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0xe3, 0x80, 0x40,
+        0x9f, 0x86, 0x88, 0x89, 0x41, 0x63, 0x80, 0xbc, 0x8d, 0x41, 0xf1, 0x8d, 0x40, 0xf3, 0x08, 0x89,
+        0x40, 0xe7, 0x01, 0x06, 0x0c, 0x80, 0x41, 0xd9, 0x86, 0xec, 0x34, 0x89, 0x52, 0x95, 0x89, 0x6c,
+        0x05, 0x05, 0x40, 0xef,
+    };
+    // [11] unicode_prop_XID_Start1_table (31 bytes)
+    internal static ReadOnlySpan<byte> PropXID_Start1Table => new byte[]
+    {
+        0x43, 0x79, 0x80, 0x4a, 0xb7, 0x80, 0xfe, 0x80, 0x60, 0x21, 0xe6, 0x81, 0x60, 0xcb, 0xc0, 0x85,
+        0x41, 0x95, 0x81, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x41, 0x1e, 0x81,
+    };
+    // [12] unicode_prop_XID_Continue1_table (23 bytes)
+    internal static ReadOnlySpan<byte> PropXID_Continue1Table => new byte[]
+    {
+        0x43, 0x79, 0x80, 0x60, 0x2d, 0x1f, 0x81, 0x60, 0xcb, 0xc0, 0x85, 0x41, 0x95, 0x81, 0xf3, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+    };
+    // [13] unicode_prop_Changes_When_Titlecased1_table (22 bytes)
+    internal static ReadOnlySpan<byte> PropChanges_When_Titlecased1Table => new byte[]
+    {
+        0x41, 0xc3, 0x08, 0x08, 0x81, 0xa4, 0x81, 0x4e, 0xdc, 0xaa, 0x0a, 0x4e, 0x87, 0x3f, 0x3f, 0x87,
+        0x8b, 0x80, 0x8e, 0x80, 0xae, 0x80,
+    };
+    // [14] unicode_prop_Changes_When_Casefolded1_table (29 bytes)
+    internal static ReadOnlySpan<byte> PropChanges_When_Casefolded1Table => new byte[]
+    {
+        0x41, 0xef, 0x80, 0x41, 0x9e, 0x80, 0x9e, 0x80, 0x5a, 0xe4, 0x83, 0x40, 0xb5, 0x00, 0x00, 0x00,
+        0x80, 0xde, 0x06, 0x06, 0x80, 0x8a, 0x09, 0x81, 0x89, 0x10, 0x81, 0x8d, 0x80,
+    };
+    // [15] unicode_prop_Changes_When_NFKC_Casefolded1_table (449 bytes)
+    internal static ReadOnlySpan<byte> PropChanges_When_NFKC_Casefolded1Table => new byte[]
+    {
+        0x40, 0x9f, 0x06, 0x00, 0x01, 0x00, 0x01, 0x12, 0x10, 0x82, 0xf3, 0x80, 0x8b, 0x80, 0x40, 0x84,
+        0x01, 0x01, 0x80, 0xa2, 0x01, 0x80, 0x40, 0xbb, 0x88, 0x9e, 0x29, 0x84, 0xda, 0x08, 0x81, 0x89,
+        0x80, 0xa3, 0x04, 0x02, 0x04, 0x08, 0x07, 0x80, 0x9e, 0x80, 0xa0, 0x82, 0x9c, 0x80, 0x42, 0x28,
+        0x80, 0xd7, 0x83, 0x42, 0xde, 0x87, 0xfb, 0x08, 0x80, 0xd2, 0x01, 0x80, 0xa1, 0x11, 0x80, 0x40,
+        0xfc, 0x81, 0x42, 0xd4, 0x80, 0xfe, 0x80, 0xa7, 0x81, 0xad, 0x80, 0xb5, 0x80, 0x88, 0x03, 0x03,
+        0x03, 0x80, 0x8b, 0x80, 0x88, 0x00, 0x26, 0x80, 0x90, 0x80, 0x88, 0x03, 0x03, 0x03, 0x80, 0x8b,
+        0x80, 0x41, 0x41, 0x80, 0xe1, 0x81, 0x46, 0x52, 0x81, 0xd4, 0x84, 0x45, 0x1b, 0x10, 0x8a, 0x80,
+        0x91, 0x80, 0x9b, 0x8c, 0x80, 0xa1, 0xa4, 0x40, 0xd5, 0x83, 0x40, 0xb5, 0x00, 0x00, 0x00, 0x80,
+        0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xb7, 0x05, 0x00, 0x13, 0x05, 0x11, 0x02, 0x0c,
+        0x11, 0x00, 0x00, 0x0c, 0x15, 0x05, 0x08, 0x8f, 0x00, 0x20, 0x8b, 0x12, 0x2a, 0x08, 0x0b, 0x00,
+        0x07, 0x82, 0x8c, 0x06, 0x92, 0x81, 0x9a, 0x80, 0x8c, 0x8a, 0x80, 0xd6, 0x18, 0x10, 0x8a, 0x01,
+        0x0c, 0x0a, 0x00, 0x10, 0x11, 0x02, 0x06, 0x05, 0x1c, 0x85, 0x8f, 0x8f, 0x8f, 0x88, 0x80, 0x40,
+        0xa1, 0x08, 0x81, 0x40, 0xf7, 0x81, 0x41, 0x34, 0xd5, 0x99, 0x9a, 0x45, 0x20, 0x80, 0xe6, 0x82,
+        0xe4, 0x80, 0x41, 0x9e, 0x81, 0x40, 0xf0, 0x80, 0x41, 0x2e, 0x80, 0xd2, 0x80, 0x8b, 0x40, 0xd5,
+        0xa9, 0x80, 0xb4, 0x00, 0x82, 0xdf, 0x09, 0x80, 0xde, 0x80, 0xb0, 0xdd, 0x82, 0x8d, 0xdf, 0x9e,
+        0x80, 0xa7, 0x87, 0xae, 0x80, 0x41, 0x7f, 0x60, 0x72, 0x9b, 0x81, 0x40, 0xd1, 0x80, 0xff, 0x1a,
+        0x81, 0x43, 0x61, 0x83, 0x88, 0x80, 0x60, 0x4d, 0x95, 0x41, 0x0d, 0x08, 0x00, 0x81, 0x89, 0x00,
+        0x00, 0x09, 0x82, 0xc3, 0x81, 0xe9, 0xc2, 0x00, 0x97, 0x04, 0x00, 0x01, 0x01, 0x80, 0xeb, 0xa0,
+        0x41, 0x6a, 0x91, 0xbf, 0x81, 0xb5, 0xa7, 0x8c, 0x82, 0x99, 0x95, 0x94, 0x81, 0x8b, 0x80, 0x92,
+        0x03, 0x1a, 0x00, 0x80, 0x40, 0x86, 0x08, 0x80, 0x9f, 0x99, 0x40, 0x83, 0x15, 0x0d, 0x0d, 0x0a,
+        0x16, 0x06, 0x80, 0x88, 0x47, 0x87, 0x20, 0xa9, 0x80, 0x88, 0x60, 0xb4, 0xe4, 0x83, 0x50, 0x31,
+        0xa3, 0x44, 0x63, 0x86, 0x8d, 0x87, 0xbf, 0x85, 0x42, 0x3e, 0xd4, 0x80, 0xc6, 0x01, 0x08, 0x09,
+        0x0b, 0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00, 0x16,
+        0x80, 0x41, 0x53, 0x81, 0x41, 0x23, 0x81, 0xb1, 0x48, 0x2f, 0xbd, 0x4d, 0x91, 0x18, 0x9a, 0x01,
+        0x00, 0x08, 0x80, 0x89, 0x03, 0x00, 0x00, 0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x08, 0x00,
+        0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x06, 0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90, 0x22, 0x04,
+        0x80, 0x90, 0x42, 0x43, 0x8a, 0x84, 0x9e, 0x80, 0x9f, 0x99, 0x82, 0xa2, 0x80, 0xee, 0x82, 0x8c,
+        0xab, 0x83, 0x88, 0x31, 0x49, 0x9d, 0x89, 0x60, 0xfc, 0x05, 0x42, 0x1d, 0x6b, 0x05, 0xe1, 0x4f,
+        0xff,
+    };
+    // [21] unicode_prop_ASCII_Hex_Digit_table (5 bytes)
+    internal static ReadOnlySpan<byte> PropASCII_Hex_DigitTable => new byte[]
+    {
+        0xaf, 0x89, 0x35, 0x99, 0x85,
+    };
+    // [22] unicode_prop_Bidi_Control_table (10 bytes)
+    internal static ReadOnlySpan<byte> PropBidi_ControlTable => new byte[]
+    {
+        0x46, 0x1b, 0x80, 0x59, 0xf0, 0x81, 0x99, 0x84, 0xb6, 0x83,
+    };
+    // [23] unicode_prop_Dash_table (58 bytes)
+    internal static ReadOnlySpan<byte> PropDashTable => new byte[]
+    {
+        0xac, 0x80, 0x45, 0x5b, 0x80, 0xb2, 0x80, 0x4e, 0x40, 0x80, 0x44, 0x04, 0x80, 0x48, 0x08, 0x85,
+        0xbc, 0x80, 0xa6, 0x80, 0x8e, 0x80, 0x41, 0x85, 0x80, 0x4c, 0x03, 0x01, 0x80, 0x9e, 0x0b, 0x80,
+        0x9b, 0x80, 0x41, 0xbd, 0x80, 0x92, 0x80, 0xee, 0x80, 0x60, 0xcd, 0x8f, 0x81, 0xa4, 0x80, 0x89,
+        0x80, 0x40, 0xa8, 0x80, 0x4e, 0x5f, 0x80, 0x41, 0x3d, 0x80,
+    };
+    // [24] unicode_prop_Deprecated_table (23 bytes)
+    internal static ReadOnlySpan<byte> PropDeprecatedTable => new byte[]
+    {
+        0x41, 0x48, 0x80, 0x45, 0x28, 0x80, 0x49, 0x02, 0x00, 0x80, 0x48, 0x28, 0x81, 0x48, 0xc4, 0x85,
+        0x42, 0xb8, 0x81, 0x6d, 0xdc, 0xd5, 0x80,
+    };
+    // [25] unicode_prop_Diacritic_table (447 bytes)
+    internal static ReadOnlySpan<byte> PropDiacriticTable => new byte[]
+    {
+        0xdd, 0x00, 0x80, 0xc6, 0x05, 0x03, 0x01, 0x81, 0x41, 0xf6, 0x40, 0x9e, 0x07, 0x25, 0x90, 0x0b,
+        0x80, 0x88, 0x81, 0x40, 0xfc, 0x84, 0x40, 0xd0, 0x80, 0xb6, 0xac, 0x00, 0x01, 0x01, 0x00, 0x40,
+        0x82, 0x3b, 0x81, 0x40, 0x85, 0x0b, 0x0a, 0x82, 0xc2, 0x9a, 0xda, 0x8a, 0xb9, 0x8a, 0xa1, 0x81,
+        0xfd, 0x87, 0xa8, 0x89, 0x8f, 0x9b, 0xbc, 0x80, 0x8f, 0x02, 0x83, 0x9b, 0x80, 0xc9, 0x80, 0x8f,
+        0x80, 0xed, 0x80, 0x8f, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xae, 0x82, 0xbb, 0x80, 0x8f, 0x06, 0x80,
+        0xf6, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xed, 0x80, 0x8f, 0x80, 0xec, 0x81, 0x8f, 0x80, 0xfb, 0x80,
+        0xee, 0x80, 0x8b, 0x28, 0x80, 0xea, 0x80, 0x8c, 0x84, 0xca, 0x81, 0x9a, 0x00, 0x00, 0x03, 0x81,
+        0xc1, 0x10, 0x81, 0xbd, 0x80, 0xef, 0x00, 0x81, 0xa7, 0x0b, 0x84, 0x98, 0x30, 0x80, 0x89, 0x81,
+        0x42, 0xc0, 0x82, 0x43, 0xb3, 0x81, 0x9d, 0x80, 0x40, 0x93, 0x8a, 0x88, 0x80, 0x41, 0x5a, 0x82,
+        0x41, 0x23, 0x80, 0x93, 0x39, 0x80, 0xaf, 0x8e, 0x81, 0x8a, 0x82, 0x8e, 0x81, 0x8b, 0xc7, 0x80,
+        0x8e, 0x80, 0xa5, 0x88, 0xb5, 0x81, 0xb9, 0x80, 0x8a, 0x81, 0xc1, 0x81, 0xbf, 0x85, 0xd1, 0x98,
+        0x18, 0x28, 0x0a, 0xb1, 0xbe, 0xaf, 0xa3, 0x84, 0x8b, 0xa4, 0x8a, 0x41, 0xbc, 0x00, 0x82, 0x8a,
+        0x82, 0x8c, 0x82, 0x8c, 0x82, 0x8c, 0x81, 0x4c, 0xef, 0x82, 0x41, 0x3c, 0x80, 0x41, 0xf9, 0x85,
+        0xe8, 0x83, 0xde, 0x80, 0x60, 0x75, 0x71, 0x80, 0x8b, 0x08, 0x80, 0x9b, 0x81, 0xd1, 0x81, 0x8d,
+        0xa1, 0xe5, 0x82, 0xe5, 0x05, 0x81, 0x8b, 0x80, 0xa4, 0x80, 0x40, 0x96, 0x80, 0x9a, 0x91, 0xb8,
+        0x83, 0xa3, 0x80, 0xde, 0x80, 0x8b, 0x80, 0xa3, 0x80, 0x40, 0x94, 0x82, 0xc0, 0x83, 0xb2, 0x80,
+        0xe3, 0x84, 0x88, 0x82, 0xff, 0x81, 0x60, 0x4f, 0x2f, 0x80, 0x43, 0x00, 0x8f, 0x41, 0x0d, 0x00,
+        0x80, 0xae, 0x80, 0xac, 0x81, 0xc2, 0x80, 0x42, 0xfb, 0x80, 0x44, 0x9e, 0x28, 0xa9, 0x80, 0x88,
+        0x42, 0x7c, 0x13, 0x80, 0x40, 0xa4, 0x81, 0x42, 0x3a, 0x85, 0xa5, 0x80, 0x99, 0x84, 0x41, 0x8b,
+        0x01, 0x82, 0xc5, 0x8a, 0xb0, 0x83, 0x40, 0xbf, 0x80, 0xa8, 0x80, 0xc7, 0x81, 0xf7, 0x81, 0xbd,
+        0x80, 0xcb, 0x80, 0x88, 0x82, 0xe7, 0x81, 0x40, 0xb1, 0x81, 0xcf, 0x81, 0x8f, 0x80, 0x97, 0x32,
+        0x84, 0xd8, 0x10, 0x81, 0x8c, 0x81, 0xde, 0x02, 0x80, 0xfa, 0x81, 0x40, 0xfa, 0x81, 0xfd, 0x80,
+        0xf5, 0x81, 0xf2, 0x80, 0x41, 0x0c, 0x81, 0x41, 0x01, 0x0b, 0x80, 0x40, 0x9b, 0x80, 0xd2, 0x80,
+        0x91, 0x80, 0xd0, 0x80, 0x41, 0xa4, 0x80, 0x41, 0x01, 0x00, 0x81, 0xd0, 0x80, 0xc0, 0x80, 0x41,
+        0x66, 0x81, 0x96, 0x80, 0x54, 0xeb, 0x8e, 0x60, 0x2c, 0xd8, 0x80, 0x49, 0xbf, 0x84, 0xba, 0x86,
+        0x42, 0x33, 0x81, 0x42, 0x21, 0x90, 0xcf, 0x81, 0x60, 0x3f, 0xfd, 0x18, 0x30, 0x81, 0x5f, 0x00,
+        0xad, 0x81, 0x96, 0x42, 0x1f, 0x12, 0x2f, 0x39, 0x86, 0x9d, 0x83, 0x4e, 0x81, 0xbd, 0x40, 0xc1,
+        0x86, 0x41, 0x76, 0x80, 0xbc, 0x83, 0x42, 0xfd, 0x81, 0x42, 0xdf, 0x86, 0xec, 0x10, 0x82,
+    };
+    // [26] unicode_prop_Extender_table (116 bytes)
+    internal static ReadOnlySpan<byte> PropExtenderTable => new byte[]
+    {
+        0x40, 0xb6, 0x80, 0x42, 0x17, 0x81, 0x43, 0x6d, 0x80, 0x41, 0xb8, 0x80, 0x42, 0x75, 0x80, 0x40,
+        0x88, 0x80, 0xd8, 0x80, 0x42, 0xef, 0x80, 0xfe, 0x80, 0x49, 0x42, 0x80, 0xb7, 0x80, 0x42, 0x62,
+        0x80, 0x41, 0x8d, 0x80, 0xc3, 0x80, 0x53, 0x88, 0x80, 0xaa, 0x84, 0xe6, 0x81, 0xdc, 0x82, 0x60,
+        0x6f, 0x15, 0x80, 0x45, 0xf5, 0x80, 0x43, 0xc1, 0x80, 0x95, 0x80, 0x40, 0x88, 0x80, 0xeb, 0x80,
+        0x94, 0x81, 0x60, 0x54, 0x7a, 0x80, 0x48, 0x0f, 0x81, 0x45, 0xca, 0x80, 0x9a, 0x03, 0x80, 0x44,
+        0xc6, 0x80, 0x41, 0x24, 0x80, 0xf3, 0x81, 0x41, 0xf1, 0x82, 0x44, 0xce, 0x80, 0x43, 0x3f, 0x80,
+        0x60, 0x4d, 0x67, 0x81, 0x44, 0x9b, 0x08, 0x80, 0x8d, 0x81, 0x60, 0x71, 0x47, 0x81, 0x44, 0xb0,
+        0x80, 0x43, 0x53, 0x82,
+    };
+    // [27] unicode_prop_Hex_Digit_table (12 bytes)
+    internal static ReadOnlySpan<byte> PropHex_DigitTable => new byte[]
+    {
+        0xaf, 0x89, 0x35, 0x99, 0x85, 0x60, 0xfe, 0xa8, 0x89, 0x35, 0x99, 0x85,
+    };
+    // [28] unicode_prop_IDS_Unary_Operator_table (4 bytes)
+    internal static ReadOnlySpan<byte> PropIDS_Unary_OperatorTable => new byte[]
+    {
+        0x60, 0x2f, 0xfd, 0x81,
+    };
+    // [29] unicode_prop_IDS_Binary_Operator_table (8 bytes)
+    internal static ReadOnlySpan<byte> PropIDS_Binary_OperatorTable => new byte[]
+    {
+        0x60, 0x2f, 0xef, 0x09, 0x89, 0x41, 0xf0, 0x80,
+    };
+    // [30] unicode_prop_IDS_Trinary_Operator_table (4 bytes)
+    internal static ReadOnlySpan<byte> PropIDS_Trinary_OperatorTable => new byte[]
+    {
+        0x60, 0x2f, 0xf1, 0x81,
+    };
+    // [31] unicode_prop_Ideographic_table (71 bytes)
+    internal static ReadOnlySpan<byte> PropIdeographicTable => new byte[]
+    {
+        0x60, 0x30, 0x05, 0x81, 0x98, 0x88, 0x8d, 0x82, 0x43, 0xc4, 0x59, 0xbf, 0xbf, 0x60, 0x51, 0xff,
+        0x60, 0x58, 0xff, 0x41, 0x6d, 0x81, 0xe9, 0x60, 0x75, 0x09, 0x80, 0x8c, 0x84, 0x88, 0x5c, 0xd5,
+        0xa8, 0x9f, 0xe0, 0xf2, 0x60, 0x23, 0x7c, 0x41, 0x8b, 0x60, 0x4d, 0x03, 0x60, 0xa6, 0xdf, 0x9f,
+        0x51, 0x1d, 0x81, 0x56, 0x8d, 0x81, 0x5d, 0x30, 0x8e, 0x42, 0x6d, 0x49, 0xa1, 0x42, 0x1d, 0x45,
+        0xe1, 0x53, 0x4a, 0x84, 0x60, 0x21, 0x29,
+    };
+    // [32] unicode_prop_Join_Control_table (4 bytes)
+    internal static ReadOnlySpan<byte> PropJoin_ControlTable => new byte[]
+    {
+        0x60, 0x20, 0x0b, 0x81,
+    };
+    // [33] unicode_prop_Logical_Order_Exception_table (15 bytes)
+    internal static ReadOnlySpan<byte> PropLogical_Order_ExceptionTable => new byte[]
+    {
+        0x4e, 0x3f, 0x84, 0xfa, 0x84, 0x4a, 0xef, 0x11, 0x80, 0x60, 0x90, 0xf9, 0x09, 0x00, 0x81,
+    };
+    // [34] unicode_prop_Modifier_Combining_Mark_table (16 bytes)
+    internal static ReadOnlySpan<byte> PropModifier_Combining_MarkTable => new byte[]
+    {
+        0x46, 0x53, 0x09, 0x80, 0x40, 0x82, 0x05, 0x02, 0x81, 0x41, 0xe0, 0x08, 0x12, 0x80, 0x9e, 0x80,
+    };
+    // [35] unicode_prop_Noncharacter_Code_Point_table (71 bytes)
+    internal static ReadOnlySpan<byte> PropNoncharacter_Code_PointTable => new byte[]
+    {
+        0x60, 0xfd, 0xcf, 0x9f, 0x42, 0x0d, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60,
+        0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60,
+        0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60,
+        0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81, 0x60,
+        0xff, 0xfd, 0x81, 0x60, 0xff, 0xfd, 0x81,
+    };
+    // [36] unicode_prop_Pattern_Syntax_table (58 bytes)
+    internal static ReadOnlySpan<byte> PropPattern_SyntaxTable => new byte[]
+    {
+        0xa0, 0x8e, 0x89, 0x86, 0x99, 0x18, 0x80, 0x99, 0x83, 0xa1, 0x30, 0x00, 0x08, 0x00, 0x0b, 0x03,
+        0x02, 0x80, 0x96, 0x80, 0x9e, 0x80, 0x5f, 0x17, 0x97, 0x87, 0x8e, 0x81, 0x92, 0x80, 0x89, 0x41,
+        0x30, 0x42, 0xcf, 0x40, 0x9f, 0x42, 0x75, 0x9d, 0x44, 0x6b, 0x41, 0xff, 0xff, 0x41, 0x80, 0x13,
+        0x98, 0x8e, 0x80, 0x60, 0xcd, 0x0c, 0x81, 0x41, 0x04, 0x81,
+    };
+    // [37] unicode_prop_Pattern_White_Space_table (11 bytes)
+    internal static ReadOnlySpan<byte> PropPattern_White_SpaceTable => new byte[]
+    {
+        0x88, 0x84, 0x91, 0x80, 0xe3, 0x80, 0x5f, 0x87, 0x81, 0x97, 0x81,
+    };
+    // [38] unicode_prop_Quotation_Mark_table (31 bytes)
+    internal static ReadOnlySpan<byte> PropQuotation_MarkTable => new byte[]
+    {
+        0xa1, 0x03, 0x80, 0x40, 0x82, 0x80, 0x8e, 0x80, 0x5f, 0x5b, 0x87, 0x98, 0x81, 0x4e, 0x06, 0x80,
+        0x41, 0xc8, 0x83, 0x8c, 0x82, 0x60, 0xce, 0x20, 0x83, 0x40, 0xbc, 0x03, 0x80, 0xd9, 0x81,
+    };
+    // [39] unicode_prop_Radical_table (9 bytes)
+    internal static ReadOnlySpan<byte> PropRadicalTable => new byte[]
+    {
+        0x60, 0x2e, 0x7f, 0x99, 0x80, 0xd8, 0x8b, 0x40, 0xd5,
+    };
+    // [40] unicode_prop_Regional_Indicator_table (4 bytes)
+    internal static ReadOnlySpan<byte> PropRegional_IndicatorTable => new byte[]
+    {
+        0x61, 0xf1, 0xe5, 0x99,
+    };
+    // [41] unicode_prop_Sentence_Terminal_table (213 bytes)
+    internal static ReadOnlySpan<byte> PropSentence_TerminalTable => new byte[]
+    {
+        0xa0, 0x80, 0x8b, 0x80, 0x8f, 0x80, 0x45, 0x48, 0x80, 0x40, 0x92, 0x82, 0x40, 0xb3, 0x80, 0xaa,
+        0x82, 0x40, 0xf5, 0x80, 0xbc, 0x00, 0x02, 0x81, 0x41, 0x24, 0x81, 0x46, 0xe3, 0x81, 0x43, 0x15,
+        0x03, 0x81, 0x43, 0x04, 0x80, 0x40, 0xc5, 0x81, 0x40, 0x9c, 0x81, 0xac, 0x04, 0x80, 0x41, 0x39,
+        0x81, 0x41, 0x61, 0x83, 0x40, 0xa1, 0x81, 0x89, 0x09, 0x81, 0x9c, 0x82, 0x40, 0xba, 0x81, 0xc0,
+        0x81, 0x43, 0xa3, 0x80, 0x96, 0x81, 0x88, 0x82, 0x4c, 0xae, 0x82, 0x41, 0x31, 0x80, 0x8c, 0x80,
+        0x95, 0x81, 0x41, 0xac, 0x80, 0x60, 0x74, 0xfb, 0x80, 0x41, 0x0d, 0x81, 0x40, 0xe2, 0x02, 0x80,
+        0x41, 0x7d, 0x81, 0xd5, 0x81, 0xde, 0x80, 0x40, 0x97, 0x81, 0x40, 0x92, 0x82, 0x40, 0x8f, 0x81,
+        0x40, 0xf8, 0x80, 0x60, 0x52, 0x25, 0x01, 0x81, 0xba, 0x02, 0x81, 0x40, 0xa8, 0x80, 0x8b, 0x80,
+        0x8f, 0x80, 0xc0, 0x80, 0x4a, 0xf3, 0x81, 0x44, 0xfc, 0x84, 0xab, 0x83, 0x40, 0xbc, 0x81, 0xf4,
+        0x83, 0xfe, 0x82, 0x40, 0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7, 0x08, 0x81, 0xeb, 0x80, 0x41, 0x29,
+        0x81, 0xf4, 0x81, 0x41, 0x74, 0x0c, 0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82, 0x42, 0x04, 0x00, 0x80,
+        0x40, 0xfa, 0x81, 0xd6, 0x81, 0x41, 0xa3, 0x81, 0x42, 0xb3, 0x81, 0xc9, 0x81, 0x60, 0x4b, 0x28,
+        0x81, 0x40, 0x84, 0x80, 0xc0, 0x81, 0x8a, 0x80, 0x42, 0x28, 0x81, 0x41, 0x27, 0x80, 0x60, 0x4e,
+        0x05, 0x80, 0x5d, 0xe7, 0x80,
+    };
+    // [42] unicode_prop_Soft_Dotted_table (79 bytes)
+    internal static ReadOnlySpan<byte> PropSoft_DottedTable => new byte[]
+    {
+        0xe8, 0x81, 0x40, 0xc3, 0x80, 0x41, 0x18, 0x80, 0x9d, 0x80, 0xb3, 0x80, 0x93, 0x80, 0x41, 0x3f,
+        0x80, 0xe1, 0x00, 0x80, 0x59, 0x08, 0x80, 0xb2, 0x80, 0x8c, 0x02, 0x80, 0x40, 0x83, 0x80, 0x40,
+        0x9c, 0x80, 0x41, 0xa4, 0x80, 0x40, 0xd5, 0x81, 0x4b, 0x31, 0x80, 0x61, 0xa7, 0xa4, 0x81, 0xb1,
+        0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1,
+        0x81, 0xb1, 0x81, 0xb1, 0x81, 0xb1, 0x81, 0x48, 0x85, 0x80, 0x41, 0x30, 0x81, 0x99, 0x80,
+    };
+    // [43] unicode_prop_Terminal_Punctuation_table (264 bytes)
+    internal static ReadOnlySpan<byte> PropTerminal_PunctuationTable => new byte[]
+    {
+        0xa0, 0x80, 0x89, 0x00, 0x80, 0x8a, 0x0a, 0x80, 0x43, 0x3d, 0x07, 0x80, 0x42, 0x00, 0x80, 0xb8,
+        0x80, 0xc7, 0x80, 0x8d, 0x00, 0x82, 0x40, 0xb3, 0x80, 0xaa, 0x8a, 0x00, 0x40, 0xea, 0x81, 0xb5,
+        0x28, 0x87, 0x9e, 0x80, 0x41, 0x04, 0x81, 0x44, 0xf3, 0x81, 0x40, 0xab, 0x03, 0x85, 0x41, 0x36,
+        0x81, 0x43, 0x14, 0x87, 0x43, 0x04, 0x80, 0xfb, 0x82, 0xc6, 0x81, 0x40, 0x9c, 0x12, 0x80, 0xa6,
+        0x19, 0x81, 0x41, 0x39, 0x81, 0x41, 0x61, 0x83, 0x40, 0xa1, 0x81, 0x89, 0x08, 0x82, 0x9c, 0x82,
+        0x40, 0xba, 0x84, 0xbd, 0x81, 0x43, 0xa3, 0x80, 0x96, 0x81, 0x88, 0x82, 0x4c, 0xae, 0x82, 0x41,
+        0x31, 0x80, 0x8c, 0x03, 0x80, 0x89, 0x00, 0x0a, 0x81, 0x41, 0xab, 0x81, 0x60, 0x74, 0xfa, 0x81,
+        0x41, 0x0c, 0x82, 0x40, 0xe2, 0x84, 0x41, 0x7d, 0x81, 0xd5, 0x81, 0xde, 0x80, 0x40, 0x96, 0x82,
+        0x40, 0x92, 0x82, 0xfe, 0x80, 0x8f, 0x81, 0x40, 0xf8, 0x80, 0x60, 0x52, 0x25, 0x01, 0x81, 0xb8,
+        0x10, 0x83, 0x40, 0xa8, 0x80, 0x89, 0x00, 0x80, 0x8a, 0x0a, 0x80, 0xc0, 0x01, 0x80, 0x44, 0x39,
+        0x80, 0xaf, 0x80, 0x44, 0x85, 0x80, 0x40, 0xc6, 0x80, 0x41, 0x35, 0x81, 0x40, 0x97, 0x85, 0xc3,
+        0x85, 0xd8, 0x83, 0x43, 0xb7, 0x84, 0xab, 0x83, 0x40, 0xbc, 0x86, 0xef, 0x83, 0xfe, 0x82, 0x40,
+        0x80, 0x0d, 0x80, 0x8f, 0x81, 0xd7, 0x84, 0xeb, 0x80, 0x41, 0x29, 0x81, 0xf4, 0x82, 0x8b, 0x81,
+        0x41, 0x65, 0x1a, 0x8e, 0xe8, 0x81, 0x40, 0xf8, 0x82, 0x42, 0x04, 0x00, 0x80, 0x40, 0xfa, 0x81,
+        0xd6, 0x0b, 0x81, 0x41, 0x9d, 0x82, 0xac, 0x80, 0x42, 0x84, 0x81, 0xc9, 0x81, 0x45, 0x2a, 0x84,
+        0x60, 0x45, 0xf8, 0x81, 0x40, 0x84, 0x80, 0xc0, 0x82, 0x89, 0x80, 0x42, 0x28, 0x81, 0x41, 0x26,
+        0x81, 0x60, 0x4e, 0x05, 0x80, 0x5d, 0xe6, 0x83,
+    };
+    // [44] unicode_prop_Unified_Ideograph_table (46 bytes)
+    internal static ReadOnlySpan<byte> PropUnified_IdeographTable => new byte[]
+    {
+        0x60, 0x33, 0xff, 0x59, 0xbf, 0xbf, 0x60, 0x51, 0xff, 0x60, 0x5a, 0x0d, 0x08, 0x00, 0x81, 0x89,
+        0x00, 0x00, 0x09, 0x82, 0x61, 0x05, 0xd5, 0x60, 0xa6, 0xdf, 0x9f, 0x51, 0x1d, 0x81, 0x56, 0x8d,
+        0x81, 0x5d, 0x30, 0x8e, 0x42, 0x6d, 0x51, 0xa1, 0x53, 0x4a, 0x84, 0x60, 0x21, 0x29,
+    };
+    // [45] unicode_prop_Variation_Selector_table (13 bytes)
+    internal static ReadOnlySpan<byte> PropVariation_SelectorTable => new byte[]
+    {
+        0x58, 0x0a, 0x10, 0x80, 0x60, 0xe5, 0xef, 0x8f, 0x6d, 0x02, 0xef, 0x40, 0xef,
+    };
+    // [46] unicode_prop_White_Space_table (22 bytes)
+    internal static ReadOnlySpan<byte> PropWhite_SpaceTable => new byte[]
+    {
+        0x88, 0x84, 0x91, 0x80, 0xe3, 0x80, 0x99, 0x80, 0x55, 0xde, 0x80, 0x49, 0x7e, 0x8a, 0x9c, 0x0c,
+        0x80, 0xae, 0x80, 0x4f, 0x9f, 0x80,
+    };
+    // [47] unicode_prop_Bidi_Mirrored_table (173 bytes)
+    internal static ReadOnlySpan<byte> PropBidi_MirroredTable => new byte[]
+    {
+        0xa7, 0x81, 0x91, 0x00, 0x80, 0x9b, 0x00, 0x80, 0x9c, 0x00, 0x80, 0xac, 0x80, 0x8e, 0x80, 0x4e,
+        0x7d, 0x83, 0x47, 0x5c, 0x81, 0x49, 0x9b, 0x81, 0x89, 0x81, 0xb5, 0x81, 0x8d, 0x81, 0x40, 0xb0,
+        0x80, 0x40, 0xbf, 0x1a, 0x2a, 0x02, 0x0a, 0x18, 0x18, 0x00, 0x03, 0x88, 0x20, 0x80, 0x91, 0x23,
+        0x88, 0x08, 0x00, 0x38, 0x9f, 0x0b, 0x20, 0x88, 0x09, 0x92, 0x21, 0x88, 0x21, 0x0b, 0x97, 0x81,
+        0x8f, 0x3b, 0x93, 0x0e, 0x81, 0x44, 0x3c, 0x8d, 0xc9, 0x01, 0x18, 0x08, 0x14, 0x1c, 0x12, 0x8d,
+        0x41, 0x92, 0x95, 0x0d, 0x80, 0x8d, 0x38, 0x35, 0x10, 0x1c, 0x01, 0x0c, 0x18, 0x02, 0x09, 0x89,
+        0x29, 0x81, 0x8b, 0x92, 0x03, 0x08, 0x00, 0x08, 0x03, 0x21, 0x2a, 0x97, 0x81, 0x8a, 0x0b, 0x18,
+        0x09, 0x0b, 0xaa, 0x0f, 0x80, 0xa7, 0x20, 0x00, 0x14, 0x22, 0x18, 0x14, 0x00, 0x40, 0xff, 0x80,
+        0x42, 0x02, 0x1a, 0x08, 0x81, 0x8d, 0x09, 0x89, 0xaa, 0x87, 0x41, 0xaa, 0x89, 0x0f, 0x60, 0xce,
+        0x3c, 0x2c, 0x81, 0x40, 0xa1, 0x81, 0x91, 0x00, 0x80, 0x9b, 0x00, 0x80, 0x9c, 0x00, 0x00, 0x08,
+        0x81, 0x60, 0xd7, 0x76, 0x80, 0xb8, 0x80, 0xb8, 0x80, 0xb8, 0x80, 0xb8, 0x80,
+    };
+    // [48] unicode_prop_Emoji_table (239 bytes)
+    internal static ReadOnlySpan<byte> PropEmojiTable => new byte[]
+    {
+        0xa2, 0x05, 0x04, 0x89, 0xee, 0x03, 0x80, 0x5f, 0x8c, 0x80, 0x8b, 0x80, 0x40, 0xd7, 0x80, 0x95,
+        0x80, 0xd9, 0x85, 0x8e, 0x81, 0x41, 0x6e, 0x81, 0x8b, 0x80, 0x40, 0xa5, 0x80, 0x98, 0x8a, 0x1a,
+        0x40, 0xc6, 0x80, 0x40, 0xe6, 0x81, 0x89, 0x80, 0x88, 0x80, 0xb9, 0x18, 0x84, 0x88, 0x01, 0x01,
+        0x09, 0x03, 0x01, 0x00, 0x09, 0x02, 0x02, 0x0f, 0x14, 0x00, 0x04, 0x8b, 0x8a, 0x09, 0x00, 0x08,
+        0x80, 0x91, 0x01, 0x81, 0x91, 0x28, 0x00, 0x0a, 0x0c, 0x01, 0x0b, 0x81, 0x8a, 0x0c, 0x09, 0x04,
+        0x08, 0x00, 0x81, 0x93, 0x0c, 0x28, 0x19, 0x03, 0x01, 0x01, 0x28, 0x01, 0x00, 0x00, 0x05, 0x02,
+        0x05, 0x80, 0x89, 0x81, 0x8e, 0x01, 0x03, 0x00, 0x03, 0x10, 0x80, 0x8a, 0x81, 0xaf, 0x82, 0x88,
+        0x80, 0x8d, 0x80, 0x8d, 0x80, 0x41, 0x73, 0x81, 0x41, 0xce, 0x82, 0x92, 0x81, 0xb2, 0x03, 0x80,
+        0x44, 0xd9, 0x80, 0x8b, 0x80, 0x42, 0x58, 0x00, 0x80, 0x61, 0xbd, 0x69, 0x80, 0x40, 0xc9, 0x80,
+        0x40, 0x9f, 0x81, 0x8b, 0x81, 0x8d, 0x01, 0x89, 0xca, 0x99, 0x01, 0x96, 0x80, 0x93, 0x01, 0x88,
+        0x94, 0x81, 0x40, 0xad, 0xa1, 0x81, 0xef, 0x09, 0x02, 0x81, 0xd2, 0x0a, 0x80, 0x41, 0x06, 0x80,
+        0xbe, 0x8a, 0x28, 0x97, 0x31, 0x0f, 0x8b, 0x01, 0x19, 0x03, 0x81, 0x8c, 0x09, 0x07, 0x81, 0x88,
+        0x04, 0x82, 0x8b, 0x17, 0x11, 0x00, 0x03, 0x05, 0x02, 0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x0b, 0x82,
+        0x89, 0x10, 0x01, 0x10, 0x81, 0x89, 0x40, 0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89, 0x80,
+        0x40, 0xb8, 0xef, 0x8c, 0x82, 0x8a, 0x82, 0xb8, 0x00, 0x83, 0x8f, 0x81, 0x8b, 0x83, 0x89,
+    };
+    // [49] unicode_prop_Emoji_Component_table (28 bytes)
+    internal static ReadOnlySpan<byte> PropEmoji_ComponentTable => new byte[]
+    {
+        0xa2, 0x05, 0x04, 0x89, 0x5f, 0xd2, 0x80, 0x40, 0xd4, 0x80, 0x60, 0xdd, 0x2a, 0x80, 0x60, 0xf3,
+        0xd5, 0x99, 0x41, 0xfa, 0x84, 0x45, 0xaf, 0x83, 0x6c, 0x06, 0x6b, 0xdf,
+    };
+    // [50] unicode_prop_Emoji_Modifier_table (4 bytes)
+    internal static ReadOnlySpan<byte> PropEmoji_ModifierTable => new byte[]
+    {
+        0x61, 0xf3, 0xfa, 0x84,
+    };
+    // [51] unicode_prop_Emoji_Modifier_Base_table (71 bytes)
+    internal static ReadOnlySpan<byte> PropEmoji_Modifier_BaseTable => new byte[]
+    {
+        0x60, 0x26, 0x1c, 0x80, 0x40, 0xda, 0x80, 0x8f, 0x83, 0x61, 0xcc, 0x76, 0x80, 0xbb, 0x11, 0x01,
+        0x82, 0xf4, 0x09, 0x8a, 0x94, 0x92, 0x10, 0x1a, 0x02, 0x30, 0x00, 0x97, 0x80, 0x40, 0xc8, 0x0b,
+        0x80, 0x94, 0x03, 0x81, 0x40, 0xad, 0x12, 0x84, 0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80, 0x8a, 0x80,
+        0x42, 0x3e, 0x01, 0x07, 0x3d, 0x80, 0x88, 0x89, 0x0a, 0xb7, 0x80, 0xbc, 0x08, 0x08, 0x80, 0x90,
+        0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9, 0x88,
+    };
+    // [52] unicode_prop_Emoji_Presentation_table (145 bytes)
+    internal static ReadOnlySpan<byte> PropEmoji_PresentationTable => new byte[]
+    {
+        0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01, 0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
+        0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90, 0x0c, 0x0f, 0x04, 0x80, 0x94, 0x06, 0x08, 0x03,
+        0x01, 0x06, 0x03, 0x81, 0x9b, 0x80, 0xa2, 0x00, 0x03, 0x10, 0x80, 0xbc, 0x82, 0x97, 0x80, 0x8d,
+        0x80, 0x43, 0x5a, 0x81, 0xb2, 0x03, 0x80, 0x61, 0xc4, 0xad, 0x80, 0x40, 0xc9, 0x80, 0x40, 0xbd,
+        0x01, 0x89, 0xca, 0x99, 0x00, 0x97, 0x80, 0x93, 0x01, 0x20, 0x82, 0x94, 0x81, 0x40, 0xad, 0xa0,
+        0x8b, 0x88, 0x80, 0xc5, 0x80, 0x95, 0x8b, 0xaa, 0x1c, 0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80,
+        0x40, 0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91, 0x80, 0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf,
+        0xc5, 0x28, 0x12, 0x0b, 0x13, 0x8a, 0x0e, 0x88, 0x40, 0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80,
+        0x89, 0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x8a, 0x82, 0xb8, 0x00, 0x83, 0x8f, 0x81, 0x8b, 0x83,
+        0x89,
+    };
+    // [53] unicode_prop_Extended_Pictographic_table (254 bytes)
+    internal static ReadOnlySpan<byte> PropExtended_PictographicTable => new byte[]
+    {
+        0x40, 0xa8, 0x03, 0x80, 0x5f, 0x8c, 0x80, 0x8b, 0x80, 0x40, 0xd7, 0x80, 0x95, 0x80, 0xd9, 0x85,
+        0x8e, 0x81, 0x41, 0x6e, 0x81, 0x8b, 0x80, 0x40, 0xa5, 0x80, 0x98, 0x8a, 0x1a, 0x40, 0xc6, 0x80,
+        0x40, 0xe6, 0x81, 0x89, 0x80, 0x88, 0x80, 0xb9, 0x18, 0x84, 0x88, 0x01, 0x01, 0x09, 0x03, 0x01,
+        0x00, 0x09, 0x02, 0x02, 0x0f, 0x14, 0x00, 0x04, 0x8b, 0x8a, 0x09, 0x00, 0x08, 0x80, 0x91, 0x01,
+        0x81, 0x91, 0x28, 0x00, 0x0a, 0x0c, 0x01, 0x0b, 0x81, 0x8a, 0x0c, 0x09, 0x04, 0x08, 0x00, 0x81,
+        0x93, 0x0c, 0x28, 0x19, 0x03, 0x01, 0x01, 0x28, 0x01, 0x00, 0x00, 0x05, 0x02, 0x05, 0x80, 0x89,
+        0x81, 0x8e, 0x01, 0x03, 0x00, 0x03, 0x10, 0x80, 0x8a, 0x81, 0xaf, 0x82, 0x88, 0x80, 0x8d, 0x80,
+        0x8d, 0x80, 0x41, 0x73, 0x81, 0x41, 0xce, 0x82, 0x92, 0x81, 0xb2, 0x03, 0x80, 0x44, 0xd9, 0x80,
+        0x8b, 0x80, 0x42, 0x58, 0x00, 0x80, 0x61, 0xbd, 0x69, 0x80, 0xa6, 0x83, 0xe3, 0x8b, 0x8e, 0x81,
+        0x8e, 0x80, 0x8d, 0x81, 0xa4, 0x89, 0xef, 0x81, 0x8b, 0x81, 0x8d, 0x01, 0x89, 0x92, 0xb7, 0x9a,
+        0x8e, 0x89, 0x80, 0x93, 0x01, 0x88, 0x03, 0x88, 0x96, 0x85, 0x40, 0xbb, 0x81, 0xef, 0x09, 0x02,
+        0x81, 0xd2, 0x0a, 0x03, 0x84, 0x40, 0xfd, 0x80, 0xbe, 0x8a, 0x28, 0x97, 0x31, 0x0f, 0x8b, 0x01,
+        0x19, 0x03, 0x81, 0x8c, 0x09, 0x07, 0x81, 0x88, 0x04, 0x82, 0x8b, 0x17, 0x11, 0x00, 0x03, 0x05,
+        0x02, 0x05, 0xd5, 0xaf, 0xc5, 0x27, 0x81, 0x90, 0x10, 0x05, 0x81, 0x8c, 0x40, 0xd9, 0xa5, 0x8b,
+        0x83, 0xb7, 0x87, 0x89, 0x85, 0xa7, 0x87, 0x9d, 0x81, 0x8b, 0x19, 0x8d, 0x88, 0xa6, 0x8b, 0xae,
+        0x80, 0x89, 0x80, 0x40, 0xb8, 0xd7, 0x87, 0x8d, 0x40, 0x91, 0x40, 0xff, 0x43, 0xfd,
+    };
+    // [54] unicode_prop_Default_Ignorable_Code_Point_table (51 bytes)
+    internal static ReadOnlySpan<byte> PropDefault_Ignorable_Code_PointTable => new byte[]
+    {
+        0x40, 0xac, 0x80, 0x42, 0xa0, 0x80, 0x42, 0xcb, 0x80, 0x4b, 0x41, 0x81, 0x46, 0x52, 0x81, 0xd4,
+        0x84, 0x47, 0xfa, 0x84, 0x99, 0x84, 0xb0, 0x8f, 0x50, 0xf3, 0x80, 0x60, 0xcc, 0x9a, 0x8f, 0x40,
+        0xee, 0x80, 0x40, 0x9f, 0x80, 0xce, 0x88, 0x60, 0xbc, 0xa6, 0x83, 0x54, 0xce, 0x87, 0x6c, 0x2e,
+        0x84, 0x4f, 0xff,
+    };
+    // [55] unicode_prop_ID_Start_table (1146 bytes)
+    internal static ReadOnlySpan<byte> PropID_StartTable => new byte[]
+    {
+        0xc0, 0x99, 0x85, 0x99, 0xae, 0x80, 0x89, 0x03, 0x04, 0x96, 0x80, 0x9e, 0x80, 0x41, 0xc9, 0x83,
+        0x8b, 0x8d, 0x26, 0x00, 0x80, 0x40, 0x80, 0x20, 0x09, 0x18, 0x05, 0x00, 0x10, 0x00, 0x93, 0x80,
+        0xd2, 0x80, 0x40, 0x8a, 0x87, 0x40, 0xa5, 0x80, 0xa5, 0x08, 0x85, 0xa8, 0xc6, 0x9a, 0x1b, 0xac,
+        0xaa, 0xa2, 0x08, 0xe2, 0x00, 0x8e, 0x0e, 0x81, 0x89, 0x11, 0x80, 0x8f, 0x00, 0x9d, 0x9c, 0xd8,
+        0x8a, 0x80, 0x97, 0xa0, 0x88, 0x0b, 0x04, 0x95, 0x18, 0x88, 0x02, 0x80, 0x96, 0x98, 0x86, 0x8a,
+        0x84, 0x97, 0x06, 0x8f, 0xa9, 0xb9, 0xb5, 0x10, 0x91, 0x06, 0x89, 0x8e, 0x8f, 0x1f, 0x09, 0x81,
+        0x95, 0x06, 0x00, 0x13, 0x10, 0x8f, 0x80, 0x8c, 0x08, 0x82, 0x8d, 0x81, 0x89, 0x07, 0x2b, 0x09,
+        0x95, 0x06, 0x01, 0x01, 0x01, 0x9e, 0x18, 0x80, 0x92, 0x82, 0x8f, 0x88, 0x02, 0x80, 0x95, 0x06,
+        0x01, 0x04, 0x10, 0x91, 0x80, 0x8e, 0x81, 0x96, 0x80, 0x8a, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04,
+        0x10, 0x9d, 0x08, 0x82, 0x8e, 0x80, 0x90, 0x00, 0x2a, 0x10, 0x1a, 0x08, 0x00, 0x0a, 0x0a, 0x12,
+        0x8b, 0x95, 0x80, 0xb3, 0x38, 0x10, 0x96, 0x80, 0x8f, 0x10, 0x99, 0x10, 0x09, 0x81, 0x9d, 0x03,
+        0x38, 0x10, 0x96, 0x80, 0x89, 0x04, 0x10, 0x9d, 0x10, 0x81, 0x8e, 0x81, 0x90, 0x88, 0x02, 0x80,
+        0xa8, 0x08, 0x8f, 0x04, 0x17, 0x82, 0x97, 0x2c, 0x91, 0x82, 0x97, 0x80, 0x88, 0x00, 0x0e, 0xb9,
+        0xaf, 0x01, 0x8b, 0x86, 0xb9, 0x08, 0x00, 0x20, 0x97, 0x00, 0x80, 0x89, 0x01, 0x88, 0x01, 0x20,
+        0x80, 0x94, 0x83, 0x9f, 0x80, 0xbe, 0x38, 0xa3, 0x9a, 0x84, 0xf2, 0xaa, 0x93, 0x80, 0x8f, 0x2b,
+        0x1a, 0x02, 0x0e, 0x13, 0x8c, 0x8b, 0x80, 0x90, 0xa5, 0x00, 0x20, 0x81, 0xaa, 0x80, 0x41, 0x4c,
+        0x03, 0x0e, 0x00, 0x03, 0x81, 0xa8, 0x03, 0x81, 0xa0, 0x03, 0x0e, 0x00, 0x03, 0x81, 0x8e, 0x80,
+        0xb8, 0x03, 0x81, 0xc2, 0xa4, 0x8f, 0x8f, 0xd5, 0x0d, 0x82, 0x42, 0x6b, 0x81, 0x90, 0x80, 0x99,
+        0x84, 0xca, 0x82, 0x8a, 0x86, 0x91, 0x8c, 0x92, 0x8d, 0x91, 0x8d, 0x8c, 0x02, 0x8e, 0xb3, 0xa2,
+        0x03, 0x80, 0xc2, 0xd8, 0x86, 0xa8, 0x00, 0x84, 0xc5, 0x89, 0x9e, 0xb0, 0x9d, 0x0c, 0x8a, 0xab,
+        0x83, 0x99, 0xb5, 0x96, 0x88, 0xb4, 0xd1, 0x80, 0xdc, 0xae, 0x90, 0x87, 0xb5, 0x9d, 0x8c, 0x81,
+        0x89, 0xab, 0x99, 0xa3, 0xa8, 0x82, 0x89, 0xa3, 0x81, 0x8a, 0x84, 0xaa, 0x0a, 0xa8, 0x18, 0x28,
+        0x0a, 0x04, 0x40, 0xbf, 0xbf, 0x41, 0x15, 0x0d, 0x81, 0xa5, 0x0d, 0x0f, 0x00, 0x00, 0x00, 0x80,
+        0x9e, 0x81, 0xb4, 0x06, 0x00, 0x12, 0x06, 0x13, 0x0d, 0x83, 0x8c, 0x22, 0x06, 0xf3, 0x80, 0x8c,
+        0x80, 0x8f, 0x8c, 0xe4, 0x03, 0x01, 0x89, 0x00, 0x0d, 0x28, 0x00, 0x00, 0x80, 0x8f, 0x0b, 0x24,
+        0x18, 0x90, 0xa8, 0x4a, 0x76, 0x40, 0xe4, 0x2b, 0x11, 0x8b, 0xa5, 0x00, 0x20, 0x81, 0xb7, 0x30,
+        0x8f, 0x96, 0x88, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x86, 0x42, 0x25, 0x82, 0x98, 0x88,
+        0x34, 0x0c, 0x83, 0xd5, 0x1c, 0x80, 0xd9, 0x03, 0x84, 0xaa, 0x80, 0xdd, 0x90, 0x9f, 0xaf, 0x8f,
+        0x41, 0xff, 0x59, 0xbf, 0xbf, 0x60, 0x56, 0x8c, 0xc2, 0xad, 0x81, 0x41, 0x0c, 0x82, 0x8f, 0x89,
+        0x81, 0x93, 0xae, 0x8f, 0x9e, 0x81, 0xcf, 0xa6, 0x88, 0x81, 0xe6, 0x81, 0xd1, 0x93, 0x90, 0x02,
+        0x03, 0x80, 0x96, 0x9c, 0xb3, 0x8d, 0xb1, 0xbd, 0x2a, 0x00, 0x81, 0x8a, 0x9b, 0x89, 0x96, 0x98,
+        0x9c, 0x86, 0xae, 0x9b, 0x80, 0x8f, 0x20, 0x89, 0x89, 0x20, 0xa8, 0x96, 0x10, 0x87, 0x93, 0x96,
+        0x10, 0x82, 0xb1, 0x00, 0x11, 0x0c, 0x08, 0x00, 0x97, 0x11, 0x8a, 0x32, 0x8b, 0x29, 0x29, 0x85,
+        0x88, 0x30, 0x30, 0xaa, 0x80, 0x8d, 0x85, 0xf2, 0x9c, 0x60, 0x2b, 0xa3, 0x8b, 0x96, 0x83, 0xb0,
+        0x60, 0x21, 0x03, 0x41, 0x6d, 0x81, 0xe9, 0xa5, 0x86, 0x8b, 0x24, 0x00, 0x89, 0x80, 0x8c, 0x04,
+        0x00, 0x01, 0x01, 0x80, 0xeb, 0xa0, 0x41, 0x6a, 0x91, 0xbf, 0x81, 0xb5, 0xa7, 0x8b, 0xf3, 0x20,
+        0x40, 0x86, 0xa3, 0x99, 0x85, 0x99, 0x8a, 0xd8, 0x15, 0x0d, 0x0d, 0x0a, 0xa2, 0x8b, 0x80, 0x99,
+        0x80, 0x92, 0x01, 0x80, 0x8e, 0x81, 0x8d, 0xa1, 0xfa, 0xc4, 0xb4, 0x41, 0x0a, 0x9c, 0x82, 0xb0,
+        0xae, 0x9f, 0x8c, 0x9d, 0x84, 0xa5, 0x89, 0x9d, 0x81, 0xa3, 0x1f, 0x04, 0xa9, 0x40, 0x9d, 0x91,
+        0xa3, 0x83, 0xa3, 0x83, 0xa7, 0x87, 0xb3, 0x8b, 0x8a, 0x80, 0x8e, 0x06, 0x01, 0x80, 0x8a, 0x80,
+        0x8e, 0x06, 0x01, 0x82, 0xb3, 0x8b, 0x41, 0x36, 0x88, 0x95, 0x89, 0x87, 0x97, 0x28, 0xa9, 0x80,
+        0x88, 0xc4, 0x29, 0x00, 0xab, 0x01, 0x10, 0x81, 0x96, 0x89, 0x96, 0x88, 0x9e, 0xc0, 0x92, 0x01,
+        0x89, 0x95, 0x89, 0x99, 0x85, 0x99, 0xa5, 0xb7, 0x29, 0xbf, 0x80, 0x8e, 0x18, 0x10, 0x9c, 0xa9,
+        0x9c, 0x82, 0x9c, 0xa2, 0x38, 0x9b, 0x9a, 0xb5, 0x89, 0x95, 0x89, 0x92, 0x8c, 0x91, 0xed, 0xc8,
+        0xb6, 0xb2, 0x8c, 0xb2, 0x8c, 0xa3, 0xa5, 0x9b, 0x88, 0x96, 0x40, 0xf9, 0xa9, 0x29, 0x8f, 0x85,
+        0xb7, 0x9c, 0x89, 0x07, 0x95, 0xa9, 0x91, 0xad, 0x94, 0x9a, 0x96, 0x8b, 0xb4, 0xb8, 0x09, 0x80,
+        0x8c, 0xac, 0x9f, 0x98, 0x99, 0xa3, 0x9c, 0x01, 0x07, 0xa2, 0x10, 0x8b, 0xaf, 0x8d, 0x83, 0x94,
+        0x00, 0x80, 0xa2, 0x91, 0x80, 0x98, 0x92, 0x81, 0xbe, 0x30, 0x00, 0x18, 0x8e, 0x80, 0x89, 0x86,
+        0xae, 0xa5, 0x39, 0x09, 0x95, 0x06, 0x01, 0x04, 0x10, 0x91, 0x80, 0x8b, 0x84, 0x9d, 0x89, 0x00,
+        0x08, 0x80, 0xa5, 0x00, 0x98, 0x00, 0x80, 0xab, 0xb4, 0x91, 0x83, 0x93, 0x82, 0x9d, 0xaf, 0x93,
+        0x08, 0x80, 0x40, 0xb7, 0xae, 0xa8, 0x83, 0xa3, 0xaf, 0x93, 0x80, 0xba, 0xaa, 0x8c, 0x80, 0xc6,
+        0x9a, 0xa4, 0x86, 0x40, 0xb8, 0xab, 0xf3, 0xbf, 0x9e, 0x39, 0x01, 0x38, 0x08, 0x97, 0x8e, 0x00,
+        0x80, 0xdd, 0x39, 0xa6, 0x8f, 0x00, 0x80, 0x9b, 0x80, 0x89, 0xa7, 0x30, 0x94, 0x80, 0x8a, 0xad,
+        0x92, 0x80, 0x91, 0xc8, 0x40, 0xc6, 0xa0, 0x9e, 0x88, 0x80, 0xa4, 0x90, 0x80, 0xb0, 0x9d, 0xef,
+        0x30, 0x08, 0xa5, 0x94, 0x80, 0x98, 0x28, 0x08, 0x9f, 0x8d, 0x80, 0x96, 0xab, 0x41, 0x03, 0x92,
+        0x8e, 0x00, 0x8c, 0x80, 0xa1, 0xfb, 0x80, 0xce, 0x43, 0x99, 0xe5, 0xee, 0x90, 0x40, 0xc3, 0x4a,
+        0x4b, 0xe0, 0x8e, 0x44, 0x2f, 0x90, 0x85, 0x98, 0x4f, 0x9a, 0x84, 0x42, 0x46, 0x5a, 0xb8, 0x9d,
+        0x46, 0xe1, 0x42, 0x38, 0x86, 0x9e, 0x90, 0xce, 0x90, 0x9d, 0x91, 0xaf, 0x8f, 0x83, 0x9e, 0x94,
+        0x84, 0x92, 0x41, 0xaf, 0xac, 0x40, 0xd2, 0xbf, 0x9f, 0x98, 0x81, 0x98, 0xab, 0xca, 0x20, 0xc1,
+        0x8c, 0xbf, 0x08, 0x80, 0x8d, 0x84, 0x88, 0x5c, 0xd5, 0xa8, 0x9f, 0xe0, 0xf2, 0x60, 0x21, 0xfc,
+        0x18, 0x30, 0x08, 0x41, 0x22, 0x8e, 0x80, 0x9c, 0x11, 0x80, 0x8d, 0x1f, 0x41, 0x8b, 0x49, 0x03,
+        0xea, 0x84, 0x8c, 0x82, 0x88, 0x86, 0x89, 0x57, 0x65, 0xd4, 0x80, 0xc6, 0x01, 0x08, 0x09, 0x0b,
+        0x80, 0x8b, 0x00, 0x06, 0x80, 0xc0, 0x03, 0x0f, 0x06, 0x80, 0x9b, 0x03, 0x04, 0x00, 0x16, 0x80,
+        0x41, 0x53, 0x81, 0x98, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x80, 0x9e,
+        0x80, 0x98, 0x80, 0x9e, 0x80, 0x98, 0x07, 0x47, 0x33, 0x9e, 0x2d, 0x41, 0x04, 0xbd, 0x40, 0x91,
+        0xac, 0x89, 0x86, 0x8f, 0x80, 0x41, 0x40, 0x9d, 0x91, 0xab, 0x41, 0xe3, 0x9b, 0x40, 0xe3, 0x9d,
+        0x08, 0x40, 0xce, 0x9e, 0x02, 0x01, 0x06, 0x0c, 0x88, 0x81, 0x40, 0xdf, 0x30, 0x18, 0x08, 0x8e,
+        0x80, 0x40, 0xc4, 0xba, 0xc3, 0x30, 0x44, 0xb3, 0x18, 0x9a, 0x01, 0x00, 0x08, 0x80, 0x89, 0x03,
+        0x00, 0x00, 0x28, 0x18, 0x00, 0x00, 0x02, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+        0x0b, 0x06, 0x03, 0x03, 0x00, 0x80, 0x89, 0x80, 0x90, 0x22, 0x04, 0x80, 0x90, 0x51, 0x43, 0x60,
+        0xa6, 0xdf, 0x9f, 0x51, 0x1d, 0x81, 0x56, 0x8d, 0x81, 0x5d, 0x30, 0x8e, 0x42, 0x6d, 0x49, 0xa1,
+        0x42, 0x1d, 0x45, 0xe1, 0x53, 0x4a, 0x84, 0x60, 0x21, 0x29,
+    };
+    // [56] unicode_prop_Case_Ignorable_table (785 bytes)
+    internal static ReadOnlySpan<byte> PropCase_IgnorableTable => new byte[]
+    {
+        0xa6, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80, 0xc6, 0x03, 0x00, 0x03, 0x01, 0x81, 0x41, 0xf6,
+        0x40, 0xbf, 0x19, 0x18, 0x88, 0x08, 0x80, 0x40, 0xfa, 0x86, 0x40, 0xce, 0x04, 0x80, 0xb0, 0xac,
+        0x00, 0x01, 0x01, 0x00, 0xab, 0x80, 0x8a, 0x85, 0x89, 0x8a, 0x00, 0xa2, 0x80, 0x89, 0x94, 0x8f,
+        0x80, 0xe4, 0x38, 0x89, 0x03, 0xa0, 0x00, 0x80, 0x9d, 0x9a, 0xda, 0x8a, 0xb9, 0x8a, 0x18, 0x08,
+        0x97, 0x97, 0xaa, 0x82, 0xab, 0x06, 0x0c, 0x88, 0xa8, 0xb9, 0xb6, 0x00, 0x03, 0x3b, 0x02, 0x86,
+        0x89, 0x81, 0x8c, 0x80, 0x8e, 0x80, 0xb9, 0x03, 0x1f, 0x80, 0x93, 0x81, 0x99, 0x01, 0x81, 0xb8,
+        0x03, 0x0b, 0x09, 0x12, 0x80, 0x9d, 0x0a, 0x80, 0x8a, 0x81, 0xb8, 0x03, 0x20, 0x0b, 0x80, 0x93,
+        0x81, 0x95, 0x28, 0x80, 0xb9, 0x01, 0x00, 0x1f, 0x06, 0x81, 0x8a, 0x81, 0x9d, 0x80, 0xbc, 0x80,
+        0x8b, 0x80, 0xb1, 0x02, 0x80, 0xb6, 0x00, 0x14, 0x10, 0x1e, 0x81, 0x8a, 0x81, 0x9c, 0x80, 0xb9,
+        0x01, 0x05, 0x04, 0x81, 0x93, 0x81, 0x9b, 0x81, 0xb8, 0x0b, 0x1f, 0x80, 0x93, 0x81, 0x9c, 0x80,
+        0xc7, 0x06, 0x10, 0x80, 0xd9, 0x01, 0x86, 0x8a, 0x88, 0xe1, 0x01, 0x88, 0x88, 0x00, 0x86, 0xc8,
+        0x81, 0x9a, 0x00, 0x00, 0x80, 0xb6, 0x8d, 0x04, 0x01, 0x84, 0x8a, 0x80, 0xa3, 0x88, 0x80, 0xe5,
+        0x18, 0x28, 0x09, 0x81, 0x98, 0x0b, 0x82, 0x8f, 0x83, 0x8c, 0x01, 0x0d, 0x80, 0x8e, 0x80, 0xdd,
+        0x80, 0x42, 0x5f, 0x82, 0x43, 0xb1, 0x82, 0x9c, 0x81, 0x9d, 0x81, 0x9d, 0x81, 0xbf, 0x08, 0x37,
+        0x01, 0x8a, 0x10, 0x20, 0xac, 0x84, 0xb2, 0x80, 0xc0, 0x81, 0xa1, 0x80, 0xf5, 0x13, 0x81, 0x88,
+        0x05, 0x82, 0x40, 0xda, 0x09, 0x80, 0xb9, 0x00, 0x30, 0x00, 0x01, 0x3d, 0x89, 0x08, 0xa6, 0x07,
+        0xad, 0x81, 0x8b, 0x93, 0x83, 0xaf, 0x00, 0x20, 0x04, 0x80, 0xa7, 0x88, 0x8b, 0x81, 0x9f, 0x19,
+        0x08, 0x82, 0xb7, 0x00, 0x0a, 0x00, 0x82, 0xb9, 0x39, 0x81, 0xbf, 0x85, 0xd1, 0x10, 0x8c, 0x06,
+        0x18, 0x28, 0x11, 0xb1, 0xbe, 0x8c, 0x80, 0xa1, 0xe4, 0x41, 0xbc, 0x00, 0x82, 0x8a, 0x82, 0x8c,
+        0x82, 0x8c, 0x82, 0x8c, 0x81, 0x8b, 0x27, 0x81, 0x89, 0x01, 0x01, 0x84, 0xb0, 0x20, 0x89, 0x00,
+        0x8c, 0x80, 0x8f, 0x8c, 0xb2, 0xa0, 0x4b, 0x8a, 0x81, 0xf0, 0x82, 0xfc, 0x80, 0x8e, 0x80, 0xdf,
+        0x9f, 0xae, 0x80, 0x41, 0xd4, 0x80, 0xa3, 0x1a, 0x24, 0x80, 0xdc, 0x85, 0xdc, 0x82, 0x60, 0x6f,
+        0x15, 0x80, 0x44, 0xe1, 0x85, 0x41, 0x0d, 0x80, 0xe1, 0x18, 0x89, 0x00, 0x9b, 0x83, 0xcf, 0x81,
+        0x8d, 0xa1, 0xcd, 0x80, 0x96, 0x82, 0xe5, 0x1a, 0x0f, 0x02, 0x03, 0x80, 0x98, 0x0c, 0x80, 0x40,
+        0x96, 0x81, 0x99, 0x91, 0x8c, 0x80, 0xa5, 0x87, 0x98, 0x8a, 0xad, 0x82, 0xaf, 0x01, 0x19, 0x81,
+        0x90, 0x80, 0x94, 0x81, 0xc1, 0x29, 0x09, 0x81, 0x8b, 0x07, 0x80, 0xa2, 0x80, 0x8a, 0x80, 0xb2,
+        0x00, 0x11, 0x0c, 0x08, 0x80, 0x9a, 0x80, 0x8d, 0x0c, 0x08, 0x80, 0xe3, 0x84, 0x88, 0x82, 0xf8,
+        0x01, 0x03, 0x80, 0x60, 0x4f, 0x2f, 0x80, 0x40, 0x92, 0x90, 0x42, 0x3c, 0x8f, 0x10, 0x8b, 0x8f,
+        0xa1, 0x01, 0x80, 0x40, 0xa8, 0x06, 0x05, 0x80, 0x8a, 0x80, 0xa2, 0x00, 0x80, 0xae, 0x80, 0xac,
+        0x81, 0xc2, 0x80, 0x94, 0x82, 0x42, 0x00, 0x80, 0x40, 0xe1, 0x80, 0x40, 0x94, 0x84, 0x44, 0x04,
+        0x28, 0xa9, 0x80, 0x88, 0x42, 0x45, 0x10, 0x0c, 0x83, 0xa7, 0x13, 0x80, 0x40, 0xa4, 0x81, 0x42,
+        0x3c, 0x83, 0xa5, 0x80, 0x99, 0x20, 0x80, 0x41, 0x3a, 0x81, 0x97, 0x80, 0xb3, 0x85, 0xc5, 0x8a,
+        0xb0, 0x83, 0xfa, 0x80, 0xb5, 0x8e, 0xa8, 0x01, 0x81, 0x89, 0x82, 0xb0, 0x19, 0x09, 0x03, 0x80,
+        0x89, 0x80, 0xb1, 0x82, 0xa3, 0x20, 0x87, 0xbd, 0x80, 0x8b, 0x81, 0xb3, 0x88, 0x89, 0x19, 0x80,
+        0xde, 0x11, 0x00, 0x0d, 0x01, 0x80, 0x40, 0x9c, 0x02, 0x87, 0x94, 0x81, 0xb8, 0x0a, 0x80, 0xa4,
+        0x32, 0x84, 0xc5, 0x85, 0x8c, 0x00, 0x00, 0x80, 0x8d, 0x81, 0xd4, 0x39, 0x10, 0x80, 0x96, 0x80,
+        0xd3, 0x28, 0x03, 0x08, 0x81, 0x40, 0xed, 0x1d, 0x08, 0x81, 0x9a, 0x81, 0xd4, 0x39, 0x00, 0x81,
+        0xe9, 0x00, 0x01, 0x28, 0x80, 0xe4, 0x00, 0x01, 0x18, 0x84, 0x41, 0x02, 0x88, 0x01, 0x40, 0xff,
+        0x08, 0x03, 0x80, 0x40, 0x8f, 0x19, 0x0b, 0x80, 0x9f, 0x89, 0xa7, 0x29, 0x1f, 0x80, 0x88, 0x29,
+        0x82, 0xad, 0x8c, 0x01, 0x40, 0xc5, 0x00, 0x10, 0x80, 0x40, 0xc8, 0x30, 0x28, 0x80, 0xd1, 0x95,
+        0x0e, 0x01, 0x01, 0xf9, 0x2a, 0x00, 0x08, 0x30, 0x80, 0xc7, 0x0a, 0x00, 0x80, 0xc0, 0x80, 0x41,
+        0x18, 0x81, 0x8a, 0x81, 0xb3, 0x24, 0x00, 0x80, 0x96, 0x80, 0x54, 0xd4, 0x90, 0x85, 0x8e, 0x60,
+        0x2c, 0xc7, 0x8b, 0x12, 0x49, 0xbf, 0x84, 0xba, 0x86, 0x88, 0x83, 0x41, 0xfb, 0x82, 0xa7, 0x81,
+        0x41, 0xe1, 0x80, 0xbe, 0x90, 0xbf, 0x08, 0x81, 0x8c, 0x81, 0x60, 0x3f, 0xfb, 0x18, 0x30, 0x81,
+        0x4c, 0x9d, 0x08, 0x83, 0x52, 0x5b, 0xad, 0x81, 0x96, 0x42, 0x1f, 0x82, 0x88, 0x8f, 0x0e, 0x9d,
+        0x83, 0x40, 0x93, 0x82, 0x47, 0xba, 0xb6, 0x83, 0xb1, 0x38, 0x8d, 0x80, 0x95, 0x20, 0x8e, 0x45,
+        0x4f, 0x30, 0x90, 0x0e, 0x01, 0x04, 0x84, 0xbd, 0xa0, 0x80, 0x40, 0x9f, 0x8d, 0x41, 0x6f, 0x80,
+        0xbc, 0x83, 0x41, 0xfa, 0x84, 0x40, 0xfd, 0x81, 0x40, 0xf2, 0x01, 0x06, 0x0c, 0x80, 0x88, 0x80,
+        0x41, 0xcf, 0x86, 0xec, 0x87, 0x4a, 0xae, 0x84, 0x6c, 0x0c, 0x00, 0x80, 0x9d, 0xdf, 0xff, 0x40,
+        0xef,
+    };
+
+    // [16] PropBasic_Emoji1Table
+    internal static ReadOnlySpan<byte> PropBasic_Emoji1Table => new byte[]
+    {
+        0x60, 0x23, 0x19, 0x81, 0x40, 0xcc, 0x1a, 0x01, 0x80, 0x42, 0x08, 0x81, 0x94, 0x81, 0xb1, 0x8b,
+        0xaa, 0x80, 0x92, 0x80, 0x8c, 0x07, 0x81, 0x90, 0x0c, 0x0f, 0x04, 0x80, 0x94, 0x06, 0x08, 0x03,
+        0x01, 0x06, 0x03, 0x81, 0x9b, 0x80, 0xa2, 0x00, 0x03, 0x10, 0x80, 0xbc, 0x82, 0x97, 0x80, 0x8d,
+        0x80, 0x43, 0x5a, 0x81, 0xb2, 0x03, 0x80, 0x61, 0xc4, 0xad, 0x80, 0x40, 0xc9, 0x80, 0x40, 0xbd,
+        0x01, 0x89, 0xe5, 0x80, 0x97, 0x80, 0x93, 0x01, 0x20, 0x82, 0x94, 0x81, 0x40, 0xad, 0xa0, 0x8b,
+        0x88, 0x80, 0xc5, 0x80, 0x95, 0x8b, 0xaa, 0x1c, 0x8b, 0x90, 0x10, 0x82, 0xc6, 0x00, 0x80, 0x40,
+        0xba, 0x81, 0xbe, 0x8c, 0x18, 0x97, 0x91, 0x80, 0x99, 0x81, 0x8c, 0x80, 0xd5, 0xd4, 0xaf, 0xc5,
+        0x28, 0x12, 0x0b, 0x13, 0x8a, 0x0e, 0x88, 0x40, 0xe2, 0x8b, 0x18, 0x41, 0x1a, 0xae, 0x80, 0x89,
+        0x80, 0x40, 0xb8, 0xef, 0x8c, 0x82, 0x8a, 0x82, 0xb8, 0x00, 0x83, 0x8f, 0x81, 0x8b, 0x83, 0x89,
+    };
+    // [17] PropBasic_Emoji2Table
+    internal static ReadOnlySpan<byte> PropBasic_Emoji2Table => new byte[]
+    {
+        0x40, 0xa8, 0x03, 0x80, 0x5f, 0x8c, 0x80, 0x8b, 0x80, 0x40, 0xd7, 0x80, 0x95, 0x80, 0xd9, 0x85,
+        0x8e, 0x81, 0x41, 0x7c, 0x80, 0x40, 0xa5, 0x80, 0x9c, 0x10, 0x0c, 0x82, 0x40, 0xc6, 0x80, 0x40,
+        0xe6, 0x81, 0x89, 0x80, 0x88, 0x80, 0xb9, 0x0a, 0x84, 0x88, 0x01, 0x05, 0x03, 0x01, 0x00, 0x09,
+        0x02, 0x02, 0x0f, 0x14, 0x00, 0x80, 0x9b, 0x09, 0x00, 0x08, 0x80, 0x91, 0x01, 0x80, 0x92, 0x00,
+        0x18, 0x00, 0x0a, 0x05, 0x07, 0x81, 0x95, 0x05, 0x00, 0x00, 0x80, 0x94, 0x05, 0x09, 0x01, 0x17,
+        0x04, 0x09, 0x08, 0x01, 0x00, 0x00, 0x05, 0x02, 0x80, 0x90, 0x81, 0x8e, 0x01, 0x80, 0x9a, 0x81,
+        0xbb, 0x80, 0x41, 0x91, 0x81, 0x41, 0xce, 0x82, 0x45, 0x27, 0x80, 0x8b, 0x80, 0x42, 0x58, 0x00,
+        0x80, 0x61, 0xbe, 0xd5, 0x81, 0x8b, 0x81, 0x40, 0x81, 0x80, 0xb3, 0x80, 0x40, 0xe8, 0x01, 0x88,
+        0x88, 0x80, 0xc5, 0x80, 0x97, 0x08, 0x11, 0x81, 0xaa, 0x1c, 0x8b, 0x92, 0x00, 0x00, 0x80, 0xc6,
+        0x00, 0x80, 0x40, 0xba, 0x80, 0xca, 0x81, 0xa3, 0x09, 0x86, 0x8c, 0x01, 0x19, 0x80, 0x93, 0x01,
+        0x07, 0x81, 0x88, 0x04, 0x82, 0x8b, 0x17, 0x11, 0x00, 0x03, 0x05, 0x02, 0x05, 0x80, 0x40, 0xcf,
+        0x00, 0x82, 0x8f, 0x2a, 0x05, 0x01, 0x80,
+    };
+    // [18] PropRGI_Emoji_Modifier_SequenceTable
+    internal static ReadOnlySpan<byte> PropRGI_Emoji_Modifier_SequenceTable => new byte[]
+    {
+        0x60, 0x26, 0x1c, 0x80, 0x40, 0xda, 0x80, 0x8f, 0x83, 0x61, 0xcc, 0x76, 0x80, 0xbb, 0x11, 0x01,
+        0x82, 0xf4, 0x09, 0x8a, 0x94, 0x18, 0x8d, 0x10, 0x1a, 0x02, 0x30, 0x00, 0x97, 0x80, 0x40, 0xc8,
+        0x0b, 0x80, 0x94, 0x03, 0x81, 0x40, 0xad, 0x12, 0x84, 0xd2, 0x80, 0x8f, 0x82, 0x88, 0x80, 0x8a,
+        0x80, 0x42, 0x3e, 0x01, 0x07, 0x3d, 0x80, 0x88, 0x89, 0x0a, 0xb7, 0x80, 0xbc, 0x08, 0x08, 0x80,
+        0x90, 0x10, 0x8c, 0x40, 0xe4, 0x82, 0xa9, 0x88,
+    };
+    // [19] PropRGI_Emoji_Flag_SequenceTable
+    internal static ReadOnlySpan<byte> PropRGI_Emoji_Flag_SequenceTable => new byte[]
+    {
+        0x0c, 0x00, 0x09, 0x00, 0x04, 0x01, 0x02, 0x06, 0x03, 0x03, 0x01, 0x02, 0x01, 0x03, 0x07, 0x0d,
+        0x18, 0x00, 0x09, 0x00, 0x00, 0x89, 0x08, 0x00, 0x00, 0x81, 0x88, 0x83, 0x8c, 0x10, 0x00, 0x01,
+        0x07, 0x08, 0x29, 0x10, 0x28, 0x00, 0x80, 0x8a, 0x00, 0x0a, 0x00, 0x0e, 0x15, 0x18, 0x83, 0x89,
+        0x06, 0x00, 0x81, 0x8d, 0x00, 0x12, 0x08, 0x00, 0x03, 0x00, 0x24, 0x00, 0x05, 0x21, 0x00, 0x00,
+        0x29, 0x90, 0x00, 0x02, 0x00, 0x08, 0x09, 0x00, 0x08, 0x18, 0x8b, 0x80, 0x8c, 0x02, 0x19, 0x1a,
+        0x11, 0x00, 0x00, 0x80, 0x9c, 0x80, 0x88, 0x02, 0x00, 0x00, 0x02, 0x20, 0x88, 0x0a, 0x00, 0x03,
+        0x01, 0x02, 0x05, 0x08, 0x00, 0x01, 0x09, 0x20, 0x21, 0x18, 0x22, 0x00, 0x00, 0x00, 0x00, 0x18,
+        0x28, 0x89, 0x80, 0x8b, 0x80, 0x90, 0x80, 0x92, 0x80, 0x8d, 0x05, 0x80, 0x8a, 0x80, 0x88, 0x80,
+    };
+    // [20] PropEmoji_Keycap_SequenceTable
+    internal static ReadOnlySpan<byte> PropEmoji_Keycap_SequenceTable => new byte[]
+    {
+        0xa2, 0x05, 0x04, 0x89,
+    };
+
+    internal static ReadOnlySpan<byte> GetPropTable(int propIdx)
+    {
+        return propIdx switch
+        {
+            0 => PropHyphenTable,
+            1 => PropOther_MathTable,
+            2 => PropOther_AlphabeticTable,
+            3 => PropOther_LowercaseTable,
+            4 => PropOther_UppercaseTable,
+            5 => PropOther_Grapheme_ExtendTable,
+            6 => PropOther_Default_Ignorable_Code_PointTable,
+            7 => PropOther_ID_StartTable,
+            8 => PropOther_ID_ContinueTable,
+            9 => PropPrepended_Concatenation_MarkTable,
+            10 => PropID_Continue1Table,
+            11 => PropXID_Start1Table,
+            12 => PropXID_Continue1Table,
+            13 => PropChanges_When_Titlecased1Table,
+            14 => PropChanges_When_Casefolded1Table,
+            15 => PropChanges_When_NFKC_Casefolded1Table,
+            16 => PropBasic_Emoji1Table,
+            17 => PropBasic_Emoji2Table,
+            18 => PropRGI_Emoji_Modifier_SequenceTable,
+            19 => PropRGI_Emoji_Flag_SequenceTable,
+            20 => PropEmoji_Keycap_SequenceTable,
+            21 => PropASCII_Hex_DigitTable,
+            22 => PropBidi_ControlTable,
+            23 => PropDashTable,
+            24 => PropDeprecatedTable,
+            25 => PropDiacriticTable,
+            26 => PropExtenderTable,
+            27 => PropHex_DigitTable,
+            28 => PropIDS_Unary_OperatorTable,
+            29 => PropIDS_Binary_OperatorTable,
+            30 => PropIDS_Trinary_OperatorTable,
+            31 => PropIdeographicTable,
+            32 => PropJoin_ControlTable,
+            33 => PropLogical_Order_ExceptionTable,
+            34 => PropModifier_Combining_MarkTable,
+            35 => PropNoncharacter_Code_PointTable,
+            36 => PropPattern_SyntaxTable,
+            37 => PropPattern_White_SpaceTable,
+            38 => PropQuotation_MarkTable,
+            39 => PropRadicalTable,
+            40 => PropRegional_IndicatorTable,
+            41 => PropSentence_TerminalTable,
+            42 => PropSoft_DottedTable,
+            43 => PropTerminal_PunctuationTable,
+            44 => PropUnified_IdeographTable,
+            45 => PropVariation_SelectorTable,
+            46 => PropWhite_SpaceTable,
+            47 => PropBidi_MirroredTable,
+            48 => PropEmojiTable,
+            49 => PropEmoji_ComponentTable,
+            50 => PropEmoji_ModifierTable,
+            51 => PropEmoji_Modifier_BaseTable,
+            52 => PropEmoji_PresentationTable,
+            53 => PropExtended_PictographicTable,
+            54 => PropDefault_Ignorable_Code_PointTable,
+            55 => PropID_StartTable,
+            56 => PropCase_IgnorableTable,
+            _ => Array.Empty<byte>(),
+        };
+    }
+}
diff --git a/Jint/Runtime/RegExp/Unicode/UnicodeProperties.cs b/Jint/Runtime/RegExp/Unicode/UnicodeProperties.cs
new file mode 100644
index 0000000000..3b695accce
--- /dev/null
+++ b/Jint/Runtime/RegExp/Unicode/UnicodeProperties.cs
@@ -0,0 +1,783 @@
+// Unicode property support for JavaScript regex engine
+// Ported from QuickJS libunicode.c
+// Original copyright (c) 2017-2018 Fabrice Bellard - MIT License
+
+using System.Runtime.CompilerServices;
+
+namespace Jint.Runtime.RegExp.Unicode;
+
+internal enum CharRangeOp { Union = 0, Inter = 1, Xor = 2, Sub = 3 }
+
+internal enum RunType
+{
+    U = 0, L = 1, UF = 2, LF = 3, UL = 4, LSU = 5,
+    U2L_399_EXT2 = 6, UF_D20 = 7, UF_D1_EXT = 8, U_EXT = 9,
+    LF_EXT = 10, UF_EXT2 = 11, LF_EXT2 = 12, UF_EXT3 = 13,
+}
+
+[Flags]
+internal enum CaseMask { None = 0, U = 1, L = 2, F = 4 }
+
+/// <summary>
+/// Unicode property lookups for JS regex \p{...} patterns, case folding for /i,
+/// and character class set operations for /v flag.
+/// </summary>
+internal static class UnicodeProperties
+{
+    private const int MaxCaseConvLen = 3;
+
+    // ---- CharRange operations ----
+
+    private static void CrCompress(List<uint> pts)
+    {
+        int len = pts.Count, i = 0, k = 0;
+        while (i + 1 < len)
+        {
+            if (pts[i] == pts[i + 1]) { i += 2; continue; }
+            int j = i;
+            while (j + 3 < len && pts[j + 1] == pts[j + 2]) j += 2;
+            pts[k] = pts[i]; pts[k + 1] = pts[j + 1]; k += 2; i = j + 2;
+        }
+        if (k < len) pts.RemoveRange(k, len - k);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static void CrAddInterval(List<uint> pts, uint c1, uint c2) { pts.Add(c1); pts.Add(c2); }
+
+    public static void CrOp(List<uint> result, ReadOnlySpan<uint> a, ReadOnlySpan<uint> b, CharRangeOp op)
+    {
+        int ai = 0, bi = 0, al = a.Length, bl = b.Length;
+        for (; ; )
+        {
+            uint v;
+            if (ai < al && bi < bl)
+            {
+                if (a[ai] < b[bi]) v = a[ai++];
+                else if (a[ai] == b[bi]) { v = a[ai]; ai++; bi++; }
+                else v = b[bi++];
+            }
+            else if (ai < al) v = a[ai++];
+            else if (bi < bl) v = b[bi++];
+            else break;
+            int isIn = op switch
+            {
+                CharRangeOp.Union => (ai & 1) | (bi & 1),
+                CharRangeOp.Inter => (ai & 1) & (bi & 1),
+                CharRangeOp.Xor => (ai & 1) ^ (bi & 1),
+                CharRangeOp.Sub => (ai & 1) & ((bi & 1) ^ 1),
+                _ => 0,
+            };
+            if (isIn != (result.Count & 1)) result.Add(v);
+        }
+        CrCompress(result);
+    }
+
+    public static void CrOp(List<uint> pts, ReadOnlySpan<uint> b, CharRangeOp op)
+    {
+        uint[] a = pts.ToArray(); pts.Clear(); CrOp(pts, a, b, op);
+    }
+
+    public static void CrUnionInterval(List<uint> pts, uint c1, uint c2)
+    {
+        Span<uint> b = stackalloc uint[] { c1, c2 + 1 };
+        CrOp(pts, b, CharRangeOp.Union);
+    }
+
+    /// <summary>Upper bound sentinel for character ranges — matches compiler's CharRangeMax (one past max Unicode).</summary>
+    private const uint CharRangeMax = 0x110000;
+
+    public static void CrInvert(List<uint> pts)
+    {
+        pts.Insert(0, 0); pts.Add(CharRangeMax); CrCompress(pts);
+    }
+
+    private static void CrSortAndRemoveOverlap(List<uint> pts)
+    {
+        int cnt = pts.Count / 2;
+        if (cnt <= 1) return;
+        // Use parallel arrays instead of tuples for net462 compatibility
+        var starts = new uint[cnt];
+        var ends = new uint[cnt];
+        var indices = new int[cnt];
+        for (int i = 0; i < cnt; i++)
+        {
+            starts[i] = pts[i * 2];
+            ends[i] = pts[i * 2 + 1];
+            indices[i] = i;
+        }
+        Array.Sort(indices, (a, b) => starts[a].CompareTo(starts[b]));
+        pts.Clear();
+        uint s = starts[indices[0]], e = ends[indices[0]];
+        for (int i = 1; i < cnt; i++)
+        {
+            uint si = starts[indices[i]], ei = ends[indices[i]];
+            if (si > e) { pts.Add(s); pts.Add(e); s = si; e = ei; }
+            else if (ei > e) e = ei;
+        }
+        pts.Add(s);
+        pts.Add(e);
+    }
+
+    // ---- Case conversion ----
+    // case_conv_table1 packing: code(17 bits) | len(7 bits) | type(4 bits) | data_hi(4 bits)
+
+    private static int CaseConvEntry(Span<uint> res, uint c, int convType, int idx, uint v)
+    {
+        bool isLower = convType != 0;
+        var type = (RunType) ((v >> 4) & 0xf);
+        uint data = ((v & 0xf) << 8) | UnicodeData.CaseConvTable2[idx];
+        uint code = v >> 15;
+        switch (type)
+        {
+            case RunType.U:
+            case RunType.L:
+            case RunType.UF:
+            case RunType.LF:
+                {
+                    int t = (int) type;
+                    if (convType == (t & 1) || (t >= (int) RunType.UF && convType == 2))
+                        c = c - code + (UnicodeData.CaseConvTable1[(int) data] >> 15);
+                    break;
+                }
+            case RunType.UL:
+                {
+                    uint a = c - code;
+                    if ((a & 1) != (uint) (1 - (isLower ? 1 : 0))) break;
+                    c = (a ^ 1) + code; break;
+                }
+            case RunType.LSU:
+                {
+                    uint a = c - code; int il = isLower ? 1 : 0;
+                    if (a == 1) c = (uint) (c + 2 * il - 1);
+                    else if (a == (uint) ((1 - il) * 2)) c = (uint) (c + (2 * il - 1) * 2);
+                    break;
+                }
+            case RunType.U2L_399_EXT2:
+                if (!isLower) { res[0] = c - code + UnicodeData.CaseConvExt[(int) data >> 6]; res[1] = 0x399; return 2; }
+                c = c - code + UnicodeData.CaseConvExt[(int) data & 0x3f]; break;
+            case RunType.UF_D20:
+                if (convType == 1) break; c = data + (uint) (convType == 2 ? 0x20 : 0); break;
+            case RunType.UF_D1_EXT:
+                if (convType == 1) break; c = UnicodeData.CaseConvExt[(int) data] + (uint) (convType == 2 ? 1 : 0); break;
+            case RunType.U_EXT:
+            case RunType.LF_EXT:
+                if ((isLower ? 1 : 0) != ((int) type - (int) RunType.U_EXT)) break;
+                c = UnicodeData.CaseConvExt[(int) data]; break;
+            case RunType.LF_EXT2:
+                if (!isLower) break;
+                res[0] = c - code + UnicodeData.CaseConvExt[(int) data >> 6];
+                res[1] = UnicodeData.CaseConvExt[(int) data & 0x3f]; return 2;
+            case RunType.UF_EXT2:
+                if (convType == 1) break;
+                res[0] = c - code + UnicodeData.CaseConvExt[(int) data >> 6];
+                res[1] = UnicodeData.CaseConvExt[(int) data & 0x3f];
+                if (convType == 2) { res[0] = CaseConv1(res[0], 1); res[1] = CaseConv1(res[1], 1); }
+                return 2;
+            default: // UF_EXT3
+                if (convType == 1) break;
+                res[0] = UnicodeData.CaseConvExt[(int) data >> 8];
+                res[1] = UnicodeData.CaseConvExt[(int) ((data >> 4) & 0xf)];
+                res[2] = UnicodeData.CaseConvExt[(int) data & 0xf];
+                if (convType == 2) { res[0] = CaseConv1(res[0], 1); res[1] = CaseConv1(res[1], 1); res[2] = CaseConv1(res[2], 1); }
+                return 3;
+        }
+        res[0] = c; return 1;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static uint CaseConv1(uint c, int ct)
+    {
+        Span<uint> r = stackalloc uint[MaxCaseConvLen]; CaseConv(r, c, ct); return r[0];
+    }
+
+    /// <summary>Case-convert code point. convType: 0=upper, 1=lower, 2=casefold.</summary>
+    public static int CaseConv(Span<uint> res, uint c, int convType)
+    {
+        if (c < 128)
+        {
+            if (convType != 0) { if (c >= 'A' && c <= 'Z') c = c - 'A' + 'a'; }
+            else { if (c >= 'a' && c <= 'z') c = c - 'a' + 'A'; }
+        }
+        else
+        {
+            ReadOnlySpan<uint> t1 = UnicodeData.CaseConvTable1;
+            int lo = 0, hi = t1.Length - 1;
+            while (lo <= hi)
+            {
+                int mid = (int) ((uint) (hi + lo) / 2);
+                uint v = t1[mid], cd = v >> 15, ln = (v >> 8) & 0x7f;
+                if (c < cd) hi = mid - 1;
+                else if (c >= cd + ln) lo = mid + 1;
+                else return CaseConvEntry(res, c, convType, mid, v);
+            }
+        }
+        res[0] = c; return 1;
+    }
+
+    private static uint CaseFoldingEntry(uint c, int idx, uint v, bool isUnicode)
+    {
+        Span<uint> res = stackalloc uint[MaxCaseConvLen];
+        if (isUnicode)
+        {
+            int len = CaseConvEntry(res, c, 2, idx, v);
+            if (len == 1) c = res[0];
+            // When len > 1, the table returns a full case folding (status F).
+            // ES spec uses simple/common folding (status C/S). These characters
+            // have both a full and a common folding — apply the common one:
+            else if (c == 0xfb06) c = 0xfb05;
+            else if (c == 0x1fd3) c = 0x390;
+            else if (c == 0x1fe3) c = 0x3b0;
+        }
+        else
+        {
+            if (c < 128) { if (c >= 'a' && c <= 'z') c = c - 'a' + 'A'; }
+            else { int len = CaseConvEntry(res, c, 0, idx, v); if (len == 1 && res[0] >= 128) c = res[0]; }
+        }
+        return c;
+    }
+
+    /// <summary>JS regex Canonicalize abstract operation.</summary>
+    public static uint Canonicalize(uint c, bool isUnicode)
+    {
+        if (c < 128)
+        {
+            if (isUnicode) { if (c >= 'A' && c <= 'Z') c = c - 'A' + 'a'; }
+            else { if (c >= 'a' && c <= 'z') c = c - 'a' + 'A'; }
+        }
+        else
+        {
+            ReadOnlySpan<uint> t1 = UnicodeData.CaseConvTable1;
+            int lo = 0, hi = t1.Length - 1;
+            while (lo <= hi)
+            {
+                int mid = (int) ((uint) (hi + lo) / 2);
+                uint v = t1[mid], cd = v >> 15, ln = (v >> 8) & 0x7f;
+                if (c < cd) hi = mid - 1;
+                else if (c >= cd + ln) lo = mid + 1;
+                else return CaseFoldingEntry(c, mid, v, isUnicode);
+            }
+        }
+        return c;
+    }
+
+    // ---- UnicodeCase1 ----
+
+    private static int UnicodeCase1(List<uint> cr, CaseMask cm)
+    {
+        if (cm == CaseMask.None) return 0;
+        uint mU = (1u << 0) | (1 << 2) | (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7) | (1 << 8) | (1 << 9) | (1 << 11) | (1 << 13);
+        uint mL = (1u << 1) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6) | (1 << 10) | (1 << 12);
+        uint mF = (1u << 2) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6) | (1 << 10) | (1 << 12) | (1 << 7) | (1 << 8) | (1 << 11) | (1 << 13);
+        uint mask = 0;
+        if ((cm & CaseMask.U) != CaseMask.None) mask |= mU;
+        if ((cm & CaseMask.L) != CaseMask.None) mask |= mL;
+        if ((cm & CaseMask.F) != CaseMask.None) mask |= mF;
+        ReadOnlySpan<uint> t1 = UnicodeData.CaseConvTable1;
+        for (int idx = 0; idx < t1.Length; idx++)
+        {
+            uint v = t1[idx]; var ty = (RunType) ((v >> 4) & 0xf);
+            uint code = v >> 15, len = (v >> 8) & 0x7f;
+            if (((mask >> (int) ty) & 1) == 0) continue;
+            switch (ty)
+            {
+                case RunType.UL:
+                    if ((cm & CaseMask.U) != CaseMask.None && (cm & (CaseMask.L | CaseMask.F)) != CaseMask.None) goto default;
+                    uint off = (cm & CaseMask.U) != CaseMask.None ? 1u : 0u;
+                    for (uint i = 0; i < len; i += 2) CrAddInterval(cr, code + off + i, code + off + i + 1);
+                    break;
+                case RunType.LSU:
+                    if ((cm & CaseMask.U) != CaseMask.None && (cm & (CaseMask.L | CaseMask.F)) != CaseMask.None) goto default;
+                    if ((cm & CaseMask.U) == CaseMask.None) CrAddInterval(cr, code, code + 1);
+                    CrAddInterval(cr, code + 1, code + 2);
+                    if ((cm & CaseMask.U) != CaseMask.None) CrAddInterval(cr, code + 2, code + 3);
+                    break;
+                default: CrAddInterval(cr, code, code + len); break;
+            }
+        }
+        return 0;
+    }
+
+    // ---- CrCanonicalize ----
+
+    public static void CrCanonicalize(List<uint> points, bool isUnicode)
+    {
+        var crMask = new List<uint>(); var crInter = new List<uint>();
+        var crResult = new List<uint>(); var crSub = new List<uint>();
+        UnicodeCase1(crMask, isUnicode ? CaseMask.F : CaseMask.U);
+        CrOp(crInter, crMask.ToArray(), points.ToArray(), CharRangeOp.Inter);
+        CrInvert(crMask);
+        CrOp(crSub, crMask.ToArray(), points.ToArray(), CharRangeOp.Inter);
+        ReadOnlySpan<uint> t1 = UnicodeData.CaseConvTable1;
+        uint dS = uint.MaxValue, dE = uint.MaxValue;
+        int ti = 0; uint v = t1[ti], tc = v >> 15, tl = (v >> 8) & 0x7f;
+        for (int i = 0; i < crInter.Count; i += 2)
+            for (uint c = crInter[i]; c < crInter[i + 1]; c++)
+            {
+                while (!(c >= tc && c < tc + tl)) { ti++; v = t1[ti]; tc = v >> 15; tl = (v >> 8) & 0x7f; }
+                uint d = CaseFoldingEntry(c, ti, v, isUnicode);
+                if (dS == uint.MaxValue) { dS = d; dE = d + 1; }
+                else if (dE == d) dE++;
+                else { CrAddInterval(crResult, dS, dE); dS = d; dE = d + 1; }
+            }
+        if (dS != uint.MaxValue) CrAddInterval(crResult, dS, dE);
+        CrSortAndRemoveOverlap(crResult);
+        points.Clear();
+        CrOp(points, crResult.ToArray(), crSub.ToArray(), CharRangeOp.Union);
+    }
+
+    // ---- Name table lookup ----
+
+    private const string NameSep = "\\0";
+
+    private static int FindName(string tbl, string name)
+    {
+        int pos = 0;
+        int idx = 0;
+        while (idx < tbl.Length)
+        {
+            int ee = tbl.IndexOf(NameSep, idx, StringComparison.Ordinal);
+            if (ee < 0)
+            {
+                ee = tbl.Length;
+            }
+            int aS = idx;
+            while (aS < ee)
+            {
+                int cp = tbl.IndexOf(',', aS, ee - aS);
+                int aE = cp >= 0 ? cp : ee;
+                if (aE - aS == name.Length &&
+                    string.Compare(tbl, aS, name, 0, name.Length, StringComparison.OrdinalIgnoreCase) == 0)
+                {
+                    return pos;
+                }
+                aS = aE + 1;
+            }
+            pos++;
+            idx = ee + NameSep.Length;
+        }
+        return -1;
+    }
+
+    // ---- Unicode Script ----
+
+    public static int UnicodeScript(List<uint> cr, string scriptName, bool isExt)
+    {
+        int si = FindName(UnicodeData.ScriptNameTable, scriptName);
+        if (si < 0) return -2;
+        bool isCom = si == UnicodeData.ScriptCommon || si == UnicodeData.ScriptInherited;
+        List<uint> cr1 = isExt ? new List<uint>() : cr;
+        var cr2 = new List<uint>();
+        ReadOnlySpan<byte> tab = UnicodeData.ScriptTable;
+        int p = 0; uint c = 0;
+        while (p < tab.Length)
+        {
+            byte b = tab[p++]; int ty = b >> 7, n = b & 0x7f;
+            if (n >= 112) { n = ((n - 112) << 16) | (tab[p++] << 8) | tab[p++]; n += 96 + (1 << 12); }
+            else if (n >= 96) { n = ((n - 96) << 8) | tab[p++]; n += 96; }
+            uint c1 = c + (uint) n + 1;
+            if (ty != 0) { int sv = tab[p++]; if (sv == si || si == UnicodeData.ScriptUnknown) CrAddInterval(cr1, c, c1); }
+            c = c1;
+        }
+        if (si == UnicodeData.ScriptUnknown) CrInvert(cr1);
+        if (isExt)
+        {
+            ReadOnlySpan<byte> et = UnicodeData.ScriptExtTable;
+            p = 0; c = 0;
+            while (p < et.Length)
+            {
+                byte b = et[p++]; int n;
+                if (b < 128) n = b;
+                else if (b < 192) { n = ((b - 128) << 8) | et[p++]; n += 128; }
+                else { n = ((b - 192) << 16) | (et[p++] << 8) | et[p++]; n += 128 + (1 << 14); }
+                uint c1 = c + (uint) n + 1; int vl = et[p++];
+                if (isCom) { if (vl != 0) CrAddInterval(cr2, c, c1); }
+                else { for (int i = 0; i < vl; i++) if (et[p + i] == si) { CrAddInterval(cr2, c, c1); break; } }
+                p += vl; c = c1;
+            }
+            if (isCom) { CrInvert(cr2); CrOp(cr, cr1.ToArray(), cr2.ToArray(), CharRangeOp.Inter); }
+            else CrOp(cr, cr1.ToArray(), cr2.ToArray(), CharRangeOp.Union);
+        }
+        return 0;
+    }
+
+    // ---- Unicode General Category ----
+
+    private static int UnicodeGeneralCategory1(List<uint> cr, uint gcMask)
+    {
+        ReadOnlySpan<byte> tab = UnicodeData.GcTable;
+        int p = 0; uint c = 0;
+        while (p < tab.Length)
+        {
+            byte b = tab[p++]; int n = b >> 5, v = b & 0x1f;
+            if (n == 7)
+            {
+                n = tab[p++];
+                if (n >= 192) { n = ((n - 192) << 16) | (tab[p++] << 8) | tab[p++]; n += 7 + 128 + (1 << 14); }
+                else if (n >= 128) { n = ((n - 128) << 8) | tab[p++]; n += 7 + 128; }
+                else n += 7;
+            }
+            uint c0 = c; c += (uint) n + 1;
+            if (v == 31)
+            {
+                uint m = gcMask & ((1u << UnicodeData.GcLu) | (1u << UnicodeData.GcLl));
+                if (m != 0)
+                {
+                    if (m == ((1u << UnicodeData.GcLu) | (1u << UnicodeData.GcLl))) CrAddInterval(cr, c0, c);
+                    else { uint o = (gcMask & (1u << UnicodeData.GcLl)) != 0 ? 1u : 0u; for (uint ci = c0 + o; ci < c; ci += 2) CrAddInterval(cr, ci, ci + 1); }
+                }
+            }
+            else if (((gcMask >> v) & 1) != 0) CrAddInterval(cr, c0, c);
+        }
+        return 0;
+    }
+
+    public static int UnicodeGeneralCategory(List<uint> cr, string gcName)
+    {
+        int gi = FindName(UnicodeData.GcNameTable, gcName);
+        if (gi < 0) return -2;
+        uint m = gi <= UnicodeData.GcCo ? 1u << gi : UnicodeData.GcMaskTable[gi - UnicodeData.GcLC];
+        return UnicodeGeneralCategory1(cr, m);
+    }
+
+    // ---- Unicode Binary Property ----
+
+    private static int UnicodeProp1(List<uint> cr, int propIdx)
+    {
+        ReadOnlySpan<byte> tab = UnicodeData.GetPropTable(propIdx);
+        uint c = 0; int bit = 0, p = 0;
+        while (p < tab.Length)
+        {
+            uint c0 = c; byte b = tab[p++];
+            if (b < 64) { c += (uint) ((b >> 3) + 1); if (bit != 0) CrAddInterval(cr, c0, c); bit ^= 1; c0 = c; c += (uint) ((b & 7) + 1); }
+            else if (b >= 0x80) c += (uint) (b - 0x80 + 1);
+            else if (b < 0x60) { c += (uint) ((((b - 0x40) << 8) | tab[p]) + 1); p++; }
+            else { c += (uint) ((((b - 0x60) << 16) | (tab[p] << 8) | tab[p + 1]) + 1); p += 2; }
+            if (bit != 0) CrAddInterval(cr, c0, c);
+            bit ^= 1;
+        }
+        return 0;
+    }
+
+    public static int UnicodeProp(List<uint> cr, string propName)
+    {
+        int pi = FindName(UnicodeData.PropNameTable, propName);
+        if (pi < 0) return -2;
+        pi += UnicodeData.PropASCIIHexDigit;
+        switch (pi)
+        {
+            case UnicodeData.PropASCII: CrAddInterval(cr, 0, 0x80); return 0;
+            case UnicodeData.PropAny: CrAddInterval(cr, 0, 0x110000); return 0;
+            case UnicodeData.PropAssigned: UnicodeGeneralCategory1(cr, 1u << UnicodeData.GcCn); CrInvert(cr); return 0;
+            case UnicodeData.PropMath:
+                return PropOps(cr, PopGc, 1u << UnicodeData.GcSm, PopProp, (uint) UnicodeData.PropOtherMath, PopUnion);
+            case UnicodeData.PropLowercase:
+                return PropOps(cr, PopGc, 1u << UnicodeData.GcLl, PopProp, (uint) UnicodeData.PropOtherLowercase, PopUnion);
+            case UnicodeData.PropUppercase:
+                return PropOps(cr, PopGc, 1u << UnicodeData.GcLu, PopProp, (uint) UnicodeData.PropOtherUppercase, PopUnion);
+            case UnicodeData.PropCased:
+                return PropOps(cr, PopGc, (1u << UnicodeData.GcLu) | (1u << UnicodeData.GcLl) | (1u << UnicodeData.GcLt),
+                    PopProp, (uint) UnicodeData.PropOtherUppercase, PopUnion,
+                    PopProp, (uint) UnicodeData.PropOtherLowercase, PopUnion);
+            case UnicodeData.PropAlphabetic:
+                return PropOps(cr, PopGc,
+                    (1u << UnicodeData.GcLu) | (1u << UnicodeData.GcLl) | (1u << UnicodeData.GcLt) |
+                    (1u << UnicodeData.GcLm) | (1u << UnicodeData.GcLo) | (1u << UnicodeData.GcNl),
+                    PopProp, (uint) UnicodeData.PropOtherUppercase, PopUnion,
+                    PopProp, (uint) UnicodeData.PropOtherLowercase, PopUnion,
+                    PopProp, (uint) UnicodeData.PropOtherAlphabetic, PopUnion);
+            case UnicodeData.PropGraphemeBase:
+                return PropOps(cr, PopGc,
+                    (1u << UnicodeData.GcCc) | (1u << UnicodeData.GcCf) | (1u << UnicodeData.GcCs) |
+                    (1u << UnicodeData.GcCo) | (1u << UnicodeData.GcCn) | (1u << UnicodeData.GcZl) |
+                    (1u << UnicodeData.GcZp) | (1u << UnicodeData.GcMe) | (1u << UnicodeData.GcMn),
+                    PopProp, (uint) UnicodeData.PropOtherGraphemeExtend, PopUnion, PopInvert);
+            case UnicodeData.PropGraphemeExtend:
+                return PropOps(cr, PopGc, (1u << UnicodeData.GcMe) | (1u << UnicodeData.GcMn),
+                    PopProp, (uint) UnicodeData.PropOtherGraphemeExtend, PopUnion);
+            case UnicodeData.PropXIDStart:
+                return PropOps(cr, PopGc,
+                    (1u << UnicodeData.GcLu) | (1u << UnicodeData.GcLl) | (1u << UnicodeData.GcLt) |
+                    (1u << UnicodeData.GcLm) | (1u << UnicodeData.GcLo) | (1u << UnicodeData.GcNl),
+                    PopProp, (uint) UnicodeData.PropOtherIDStart, PopUnion,
+                    PopProp, (uint) UnicodeData.PropPatternSyntax,
+                    PopProp, (uint) UnicodeData.PropPatternWhiteSpace, PopUnion,
+                    PopProp, (uint) UnicodeData.PropXIDStart1, PopUnion,
+                    PopInvert, PopInter);
+            case UnicodeData.PropXIDContinue:
+                return PropOps(cr, PopGc,
+                    (1u << UnicodeData.GcLu) | (1u << UnicodeData.GcLl) | (1u << UnicodeData.GcLt) |
+                    (1u << UnicodeData.GcLm) | (1u << UnicodeData.GcLo) | (1u << UnicodeData.GcNl) |
+                    (1u << UnicodeData.GcMn) | (1u << UnicodeData.GcMc) | (1u << UnicodeData.GcNd) |
+                    (1u << UnicodeData.GcPc),
+                    PopProp, (uint) UnicodeData.PropOtherIDStart, PopUnion,
+                    PopProp, (uint) UnicodeData.PropOtherIDContinue, PopUnion,
+                    PopProp, (uint) UnicodeData.PropPatternSyntax,
+                    PopProp, (uint) UnicodeData.PropPatternWhiteSpace, PopUnion,
+                    PopProp, (uint) UnicodeData.PropXIDContinue1, PopUnion,
+                    PopInvert, PopInter);
+            case UnicodeData.PropChangesWhenUppercased:
+                return UnicodeCase1(cr, CaseMask.U);
+            case UnicodeData.PropChangesWhenLowercased:
+                return UnicodeCase1(cr, CaseMask.L);
+            case UnicodeData.PropChangesWhenCasemapped:
+                return UnicodeCase1(cr, CaseMask.U | CaseMask.L | CaseMask.F);
+            case UnicodeData.PropChangesWhenTitlecased:
+                return PropOps(cr, PopCase, (uint) CaseMask.U,
+                    PopProp, (uint) UnicodeData.PropChangesWhenTitlecased1, PopXor);
+            case UnicodeData.PropChangesWhenCasefolded:
+                return PropOps(cr, PopCase, (uint) CaseMask.F,
+                    PopProp, (uint) UnicodeData.PropChangesWhenCasefolded1, PopXor);
+            case UnicodeData.PropChangesWhenNFKCCasefolded:
+                return PropOps(cr, PopCase, (uint) CaseMask.F,
+                    PopProp, (uint) UnicodeData.PropChangesWhenNFKCCasefolded1, PopXor);
+            case UnicodeData.PropIDContinue:
+                return PropOps(cr, PopProp, (uint) UnicodeData.PropIDStart,
+                    PopProp, (uint) UnicodeData.PropIDContinue1, PopXor);
+            default:
+                if (pi >= UnicodeData.PropTableCount) return -2;
+                return UnicodeProp1(cr, pi);
+        }
+    }
+
+    // ---- Property ops stack machine ----
+
+    private const uint PopGc = 0;
+    private const uint PopProp = 1;
+    private const uint PopCase = 2;
+    private const uint PopUnion = 3;
+    private const uint PopInter = 4;
+    private const uint PopXor = 5;
+    private const uint PopInvert = 6;
+
+    private static int PropOps(List<uint> cr, params uint[] ops)
+    {
+        var stk = new List<List<uint>>();
+        int i = 0;
+        while (i < ops.Length)
+        {
+            uint op = ops[i++];
+            switch (op)
+            {
+                case PopGc:
+                    {
+                        var s = new List<uint>();
+                        if (UnicodeGeneralCategory1(s, ops[i++]) < 0)
+                        {
+                            return -1;
+                        }
+                        stk.Add(s);
+                        break;
+                    }
+                case PopProp:
+                    {
+                        var s = new List<uint>();
+                        if (UnicodeProp1(s, (int) ops[i++]) < 0)
+                        {
+                            return -1;
+                        }
+                        stk.Add(s);
+                        break;
+                    }
+                case PopCase:
+                    {
+                        var s = new List<uint>();
+                        if (UnicodeCase1(s, (CaseMask) ops[i++]) < 0)
+                        {
+                            return -1;
+                        }
+                        stk.Add(s);
+                        break;
+                    }
+                case PopUnion:
+                case PopInter:
+                case PopXor:
+                    {
+                        var b2 = stk[stk.Count - 1];
+                        stk.RemoveAt(stk.Count - 1);
+                        var a2 = stk[stk.Count - 1];
+                        stk.RemoveAt(stk.Count - 1);
+                        var r = new List<uint>();
+                        CrOp(r, a2.ToArray(), b2.ToArray(), (CharRangeOp) (op - PopUnion));
+                        stk.Add(r);
+                        break;
+                    }
+                case PopInvert:
+                    {
+                        CrInvert(stk[stk.Count - 1]);
+                        break;
+                    }
+            }
+        }
+        if (stk.Count == 1)
+        {
+            cr.AddRange(stk[0]);
+            return 0;
+        }
+        return -1;
+    }
+
+    // ---- Sequence properties ----
+
+    public static int UnicodeSequenceProp(string propName, Action<uint[], int> cb, List<uint> cr)
+    {
+        int si = FindName(UnicodeData.SequencePropNameTable, propName);
+        return si < 0 ? -2 : SeqProp1(si, cb, cr);
+    }
+
+    private static int SeqProp1(int si, Action<uint[], int> cb, List<uint> cr)
+    {
+        var seq = new uint[16];
+        switch (si)
+        {
+            case UnicodeData.SeqPropBasicEmoji:
+                if (UnicodeProp1(cr, UnicodeData.PropBasicEmoji1) < 0) return -1;
+                for (int i = 0; i < cr.Count; i += 2) for (uint c = cr[i]; c < cr[i + 1]; c++) { seq[0] = c; cb(seq, 1); }
+                cr.Clear();
+                if (UnicodeProp1(cr, UnicodeData.PropBasicEmoji2) < 0) return -1;
+                for (int i = 0; i < cr.Count; i += 2) for (uint c = cr[i]; c < cr[i + 1]; c++) { seq[0] = c; seq[1] = 0xfe0f; cb(seq, 2); }
+                break;
+            case UnicodeData.SeqPropRGIEmojiModifierSequence:
+                if (UnicodeProp1(cr, UnicodeData.PropEmojiModifierBase) < 0) return -1;
+                for (int i = 0; i < cr.Count; i += 2) for (uint c = cr[i]; c < cr[i + 1]; c++) for (int j = 0; j < 5; j++) { seq[0] = c; seq[1] = (uint) (0x1f3fb + j); cb(seq, 2); }
+                break;
+            case UnicodeData.SeqPropRGIEmojiFlagSequence:
+                if (UnicodeProp1(cr, UnicodeData.PropRGIEmojiFlagSequence) < 0) return -1;
+                for (int i = 0; i < cr.Count; i += 2) for (uint c = cr[i]; c < cr[i + 1]; c++) { seq[0] = 0x1F1E6 + c / 26; seq[1] = 0x1F1E6 + c % 26; cb(seq, 2); }
+                break;
+            case UnicodeData.SeqPropRGIEmojiZWJSequence:
+                {
+                    ReadOnlySpan<byte> tab = UnicodeData.RgiEmojiZwjSequence;
+                    int p = 0;
+                    while (p < tab.Length)
+                    {
+                        int entryLen = tab[p++];
+                        int k = 0;
+                        int mod = 0;
+                        int mc = 0;
+                        int[] mp = new int[2];
+                        int hp = -1;
+                        for (int j = 0; j < entryLen; j++)
+                        {
+                            int cd = tab[p++] | (tab[p++] << 8);
+                            int pres = cd >> 15;
+                            int m1 = (cd >> 13) & 3;
+                            cd &= 0x1FFF;
+                            uint cv = cd < 0x1000 ? (uint) (cd + 0x2000) : (uint) (0x1F000 + cd - 0x1000);
+                            if (cv == 0x1F9B0)
+                            {
+                                hp = k;
+                            }
+                            seq[k++] = cv;
+                            if (m1 != 0)
+                            {
+                                mod = m1;
+                                if (mc < 2)
+                                {
+                                    mp[mc] = k;
+                                }
+                                mc++;
+                                seq[k++] = 0;
+                            }
+                            if (pres != 0)
+                            {
+                                seq[k++] = 0xFE0F;
+                            }
+                            if (j < entryLen - 1)
+                            {
+                                seq[k++] = 0x200D;
+                            }
+                        }
+
+                        int nm = mod switch { 1 => 5, 2 => 25, 3 => 20, _ => 1 };
+                        int nh = hp >= 0 ? 4 : 1;
+                        for (int hi = 0; hi < nh; hi++)
+                        {
+                            for (int mi = 0; mi < nm; mi++)
+                            {
+                                if (hp >= 0)
+                                {
+                                    seq[hp] = (uint) (0x1F9B0 + hi);
+                                }
+                                if (mod == 1)
+                                {
+                                    seq[mp[0]] = (uint) (0x1F3FB + mi);
+                                }
+                                else if (mod >= 2)
+                                {
+                                    int i0 = mi / 5;
+                                    int i1 = mi % 5;
+                                    if (mod == 3 && i0 >= i1)
+                                    {
+                                        i0++;
+                                    }
+                                    seq[mp[0]] = (uint) (0x1F3FB + i0);
+                                    if (mc > 1)
+                                    {
+                                        seq[mp[1]] = (uint) (0x1F3FB + i1);
+                                    }
+                                }
+                                cb(seq, k);
+                            }
+                        }
+                    }
+                    break;
+                }
+            case UnicodeData.SeqPropRGIEmojiTagSequence:
+                {
+                    ReadOnlySpan<byte> tab = UnicodeData.RgiEmojiTagSequence;
+                    int p = 0;
+                    while (p < tab.Length)
+                    {
+                        int j = 0;
+                        seq[j++] = 0x1F3F4;
+                        for (; ; )
+                        {
+                            int cv = tab[p++];
+                            if (cv == 0)
+                            {
+                                break;
+                            }
+                            seq[j++] = (uint) (0xE0000 + cv);
+                        }
+                        seq[j++] = 0xE007F;
+                        cb(seq, j);
+                    }
+                    break;
+                }
+            case UnicodeData.SeqPropEmojiKeycapSequence:
+                {
+                    if (UnicodeProp1(cr, UnicodeData.PropEmojiKeycapSequence) < 0)
+                    {
+                        return -1;
+                    }
+                    for (int i = 0; i < cr.Count; i += 2)
+                    {
+                        for (uint c = cr[i]; c < cr[i + 1]; c++)
+                        {
+                            seq[0] = c;
+                            seq[1] = 0xFE0F;
+                            seq[2] = 0x20E3;
+                            cb(seq, 3);
+                        }
+                    }
+                    break;
+                }
+            case UnicodeData.SeqPropRGIEmoji:
+                {
+                    for (int i = UnicodeData.SeqPropBasicEmoji; i <= UnicodeData.SeqPropRGIEmojiZWJSequence; i++)
+                    {
+                        int r = SeqProp1(i, cb, cr);
+                        if (r < 0)
+                        {
+                            return r;
+                        }
+                        cr.Clear();
+                    }
+                    break;
+                }
+            default:
+                return -2;
+        }
+        return 0;
+    }
+}